feat: code extraction from astro files

Author: cjlyons

eslint.config.js

@@ -13,7 +13,7 @@ export default [
       'docs/architecture/**',
       'tools/**',
       'site/**',
-      // `src/extractors/builtin/basic-astro`,
+      `src/extractors/builtin/basic-astro`,
     ],
   },
 

src/extractors/builtin/basic-astro/code-extractor.ts

@@ -0,0 +1,101 @@
+/**
+ * @module basic-astro
+ * Extract TypeScript/JavaScript code from Astro frontmatter
+ * Reuses basic-node extractors by parsing frontmatter as TypeScript
+ */
+
+import { Project, ts } from 'ts-morph';
+import { createLogger } from '../../../core/logger.js';
+import { extractClasses } from '../basic-node/class-extractor.js';
+import {
+  extractFunctions,
+  extractArrowFunctions,
+} from '../basic-node/function-extractor.js';
+import { extractTypeAliases, extractInterfaces } from '../basic-node/type-extractor.js';
+import type {
+  ExtractedClass,
+  ExtractedFunction,
+  ExtractedType,
+  ExtractedInterface,
+} from '../basic-node/types.js';
+
+const log = createLogger({ context: 'AstroCodeExtractor' });
+
+export interface CodeExtractionResult {
+  classes: ExtractedClass[];
+  functions: ExtractedFunction[];
+  types: ExtractedType[];
+  interfaces: ExtractedInterface[];
+}
+
+/**
+ * Extract TypeScript/JavaScript code from Astro frontmatter
+ * Parses the frontmatter as TypeScript and uses basic-node extractors
+ *
+ * @param frontmatter - The frontmatter content (code between --- markers)
+ * @param filePath - Original Astro file path (for error reporting)
+ * @returns Extracted code items (classes, functions, types, interfaces)
+ */
+export function extractCodeFromFrontmatter(
+  frontmatter: string,
+  filePath: string,
+): CodeExtractionResult {
+  // Return empty result if no frontmatter
+  if (!frontmatter || frontmatter.trim().length === 0) {
+    return {
+      classes: [],
+      functions: [],
+      types: [],
+      interfaces: [],
+    };
+  }
+
+  try {
+    // Create a ts-morph project to parse the frontmatter
+    const project = new Project({
+      compilerOptions: {
+        allowJs: true,
+        jsx: ts.JsxEmit.React,
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.ESNext,
+      },
+      skipAddingFilesFromTsConfig: true,
+      useInMemoryFileSystem: true,
+    });
+
+    // Create a virtual .ts file with the frontmatter content
+    // Use original file path with .ts extension for better error messages
+    const virtualPath = filePath.replace(/\.astro$/, '.frontmatter.ts');
+    const sourceFile = project.createSourceFile(virtualPath, frontmatter);
+
+    // Extract code using basic-node extractors
+    const classes = extractClasses(sourceFile);
+    const regularFunctions = extractFunctions(sourceFile);
+    const arrowFunctions = extractArrowFunctions(sourceFile);
+    const functions = [...regularFunctions, ...arrowFunctions];
+    const types = extractTypeAliases(sourceFile);
+    const interfaces = extractInterfaces(sourceFile);
+
+    log.debug(
+      `Extracted from ${filePath} frontmatter: ${classes.length} classes, ${functions.length} functions, ${types.length} types, ${interfaces.length} interfaces`,
+    );
+
+    return {
+      classes,
+      functions,
+      types,
+      interfaces,
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    log.warn(`Failed to extract code from ${filePath} frontmatter: ${errorMsg}`);
+
+    // Return empty result on error
+    return {
+      classes: [],
+      functions: [],
+      types: [],
+      interfaces: [],
+    };
+  }
+}

src/extractors/builtin/basic-astro/file-parser.ts

@@ -12,6 +12,7 @@ import {
   extractFileActors,
   extractFileRelationships,
 } from './component-detector.js';
+import { extractCodeFromFrontmatter } from './code-extractor.js';
 import type { FileExtraction, ExtractedComponent } from './types.js';
 
 const log = createLogger({ context: 'AstroFileParser' });
@@ -55,15 +56,20 @@ export async function parseFiles(filePaths: string[]): Promise<FileExtraction[]>
       // Extract component usage from template
       const componentUsage = extractComponentUsage(content, imports, filePath);
 
+      // Extract TypeScript/JavaScript code from frontmatter
+      const codeExtraction = extractCodeFromFrontmatter(frontmatter, filePath);
+
       results.push({
         filePath,
         language: 'astro',
         component,
         actors,
         relationships,
         components: componentUsage,
-        functions: [], // Will be populated from frontmatter TS/JS
-        classes: [], // Will be populated from frontmatter TS/JS
+        functions: codeExtraction.functions,
+        classes: codeExtraction.classes,
+        types: codeExtraction.types,
+        interfaces: codeExtraction.interfaces,
         imports,
         parseError:
           parseResult.diagnostics && parseResult.diagnostics.length > 0
@@ -78,6 +84,8 @@ export async function parseFiles(filePaths: string[]): Promise<FileExtraction[]>
         filePath,
         language: 'astro',
         component: undefined,
+        types: [],
+        interfaces: [],
         actors: [],
         relationships: [],
         components: [],

src/extractors/builtin/basic-astro/types.ts

@@ -4,6 +4,32 @@
  * Intermediate representations before mapping to ArchletteIR
  */
 
+// Import code-related types from basic-node (reused for frontmatter analysis)
+import type {
+  ExtractedClass,
+  ExtractedFunction,
+  ExtractedType,
+  ExtractedInterface,
+  ExtractedMethod,
+  ParameterInfo,
+  DocInfo,
+  DeprecationInfo,
+  SourceLocation,
+} from '../basic-node/types.js';
+
+// Re-export for external use
+export type {
+  ExtractedClass,
+  ExtractedFunction,
+  ExtractedType,
+  ExtractedInterface,
+  ExtractedMethod,
+  ParameterInfo,
+  DocInfo,
+  DeprecationInfo,
+  SourceLocation,
+};
+
 export interface ExtractorInputs {
   include?: string[];
   exclude?: string[];
@@ -46,6 +72,8 @@ export interface FileExtraction {
   components: ExtractedComponent[];
   functions: ExtractedFunction[];
   classes: ExtractedClass[];
+  types: ExtractedType[];
+  interfaces: ExtractedInterface[];
   imports: ExtractedImport[];
   parseError?: string;
   packageInfo?: PackageInfo;
@@ -79,69 +107,13 @@ export interface ExtractedSlot {
   location: SourceLocation;
 }
 
-export interface ExtractedClass {
-  name: string;
-  isExported: boolean;
-  location: SourceLocation;
-  documentation?: DocInfo;
-  methods: ExtractedMethod[];
-}
-
-export interface ExtractedMethod {
-  name: string;
-  visibility: 'public' | 'private' | 'protected';
-  isStatic: boolean;
-  isAsync: boolean;
-  location: SourceLocation;
-  documentation?: DocInfo;
-  parameters: ParameterInfo[];
-  returnType?: string;
-}
-
-export interface ExtractedFunction {
-  name: string;
-  isExported: boolean;
-  isAsync: boolean;
-  location: SourceLocation;
-  documentation?: DocInfo;
-  parameters: ParameterInfo[];
-  returnType?: string;
-}
-
 export interface ExtractedImport {
   source: string;
   importedNames: string[];
   isDefault: boolean;
   isNamespace: boolean;
 }
 
-export interface ParameterInfo {
-  name: string;
-  type?: string;
-  description?: string;
-  optional: boolean;
-  defaultValue?: string;
-}
-
-export interface DocInfo {
-  summary?: string;
-  details?: string;
-  examples?: string[];
-  remarks?: string[];
-  seeAlso?: string[];
-}
-
-export interface DeprecationInfo {
-  reason?: string;
-  alternative?: string;
-}
-
-export interface SourceLocation {
-  filePath: string;
-  line: number;
-  column: number;
-}
-
 /**
  * Output structure from Astro compiler
  */