@foxlight/analyzer 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# @foxlight/analyzer
+
+Static analysis engine for [Foxlight](https://github.com/josegabrielcruz/foxlight) — the open-source front-end intelligence platform.
+
+## What's Inside
+
+- **AST Scanner** — TypeScript compiler API-based extraction of imports, exports, JSX usage, and function declarations
+- **Component Detector** — heuristic detection of React/Vue/Svelte/Angular components with cross-referencing
+- **Prop Extractor** — TypeScript type-checker based prop extraction with defaults and JSDoc descriptions
+- **Vue SFC Parser** — parses `.vue` Single File Components (`<script setup>`, `defineProps`, template scanning)
+- **Svelte Parser** — parses `.svelte` files (`export let` props, module scripts, template child detection)
+- **Project Analyzer** — orchestrates full-project analysis with glob matching, multi-framework support, and dependency graph construction
+
+## Installation
+
+```bash
+npm install @foxlight/analyzer
+```
+
+> **Note:** `typescript` is a peer dependency. Make sure it's installed in your project.
+
+## Usage
+
+```typescript
+import { analyzeProject, analyzeFile, detectComponents } from '@foxlight/analyzer';
+
+// Analyze an entire project
+const result = await analyzeProject('/path/to/project');
+console.log(result.stats.componentsFound);
+console.log(result.registry.getAllComponents());
+
+// Analyze a single file
+const fileAnalysis = await analyzeFile('/path/to/Button.tsx');
+const components = detectComponents(fileAnalysis, 'react');
+
+// Parse Vue SFCs
+import { parseVueSFC } from '@foxlight/analyzer';
+const vue = parseVueSFC(sourceCode, 'MyComponent.vue');
+
+// Parse Svelte files
+import { parseSvelteFile } from '@foxlight/analyzer';
+const svelte = parseSvelteFile(sourceCode, 'Counter.svelte');
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,160 @@
+import { ImportEdge, ComponentInfo, Framework, PropInfo, FoxlightConfig, ComponentRegistry, DependencyGraph } from '@foxlight/core';
+import ts from 'typescript';
+
+/** Raw information extracted from a single source file. */
+interface FileAnalysis {
+    filePath: string;
+    imports: ImportEdge[];
+    exports: ExportInfo[];
+    jsxElements: JsxElementInfo[];
+    functionDeclarations: FunctionInfo[];
+    /** Whether this file contains JSX */
+    hasJsx: boolean;
+}
+interface ExportInfo {
+    name: string;
+    kind: 'function' | 'class' | 'variable' | 'type' | 'interface' | 're-export';
+    isDefault: boolean;
+    line: number;
+}
+interface JsxElementInfo {
+    /** Tag name (e.g. "Button", "div") */
+    tagName: string;
+    /** Whether this is a component (PascalCase) or native element */
+    isComponent: boolean;
+    line: number;
+    /** Props passed to this element */
+    props: string[];
+}
+interface FunctionInfo {
+    name: string;
+    line: number;
+    /** Whether this function returns JSX */
+    returnsJsx: boolean;
+    /** Parameter names and types */
+    parameters: Array<{
+        name: string;
+        type: string;
+    }>;
+    isExported: boolean;
+    isDefault: boolean;
+    isArrowFunction: boolean;
+}
+/**
+ * Parse a TypeScript/JavaScript file and extract structural information.
+ */
+declare function analyzeFile(filePath: string): Promise<FileAnalysis>;
+/**
+ * Parse source code and extract structural information.
+ * This is the testable core — accepts raw source text.
+ */
+declare function analyzeSource(source: string, filePath: string): FileAnalysis;
+
+/**
+ * Detect components from a file analysis result.
+ * Uses heuristics appropriate for the given framework.
+ */
+declare function detectComponents(analysis: FileAnalysis, framework: Framework): ComponentInfo[];
+/**
+ * After all files are analyzed, cross-reference to populate `usedBy` fields.
+ * This connects the "children" references (forward) to "usedBy" references (backward).
+ */
+declare function crossReferenceComponents(components: ComponentInfo[]): ComponentInfo[];
+
+/**
+ * Create a TypeScript program for type-checking source files.
+ * Returns a checker that can resolve types across the project.
+ */
+declare function createTypeChecker(filePaths: string[], compilerOptions?: ts.CompilerOptions): ts.TypeChecker | null;
+/**
+ * Extract detailed prop information from a function's first parameter
+ * using the TypeScript type checker.
+ */
+declare function extractPropsFromType(checker: ts.TypeChecker, node: ts.FunctionDeclaration | ts.ArrowFunction | ts.FunctionExpression): PropInfo[];
+/**
+ * Extract prop information from a resolved TypeScript type.
+ * Handles interfaces, type aliases, intersections, and mapped types.
+ */
+declare function extractPropsFromTsType(checker: ts.TypeChecker, type: ts.Type): PropInfo[];
+/**
+ * Extract props from a source file by finding component functions
+ * and resolving their parameter types.
+ */
+declare function extractAllPropsFromFile(checker: ts.TypeChecker, sourceFile: ts.SourceFile): Map<string, PropInfo[]>;
+
+/** Result of a full project analysis. */
+interface ProjectAnalysis {
+    config: FoxlightConfig;
+    registry: ComponentRegistry;
+    graph: DependencyGraph;
+    stats: AnalysisStats;
+}
+interface AnalysisStats {
+    filesScanned: number;
+    componentsFound: number;
+    importsTracked: number;
+    duration: number;
+}
+/**
+ * Analyze an entire project directory.
+ * This is the main entry point for the analyzer.
+ */
+declare function analyzeProject(rootDir: string, configOverrides?: Partial<FoxlightConfig>): Promise<ProjectAnalysis>;
+
+/** Extracted information from a .vue file. */
+interface VueSFCAnalysis {
+    /** Component name (from filename or defineComponent name) */
+    name: string;
+    /** Script content (if present) */
+    scriptContent: string | null;
+    /** Whether the script uses <script setup> */
+    isScriptSetup: boolean;
+    /** Template content (if present) */
+    templateContent: string | null;
+    /** Whether the file has scoped styles */
+    hasScopedStyles: boolean;
+    /** Imports extracted from script block */
+    imports: ImportEdge[];
+    /** Props extracted from defineProps / props option */
+    props: PropInfo[];
+    /** Child components referenced in the template */
+    childComponents: string[];
+}
+/**
+ * Parse a Vue SFC file and extract component information.
+ */
+declare function parseVueSFC(source: string, filePath: string): VueSFCAnalysis;
+/**
+ * Convert a Vue SFC analysis result to a ComponentInfo.
+ */
+declare function vueSFCToComponentInfo(analysis: VueSFCAnalysis, filePath: string): ComponentInfo;
+
+/** Extracted information from a .svelte file. */
+interface SvelteFileAnalysis {
+    /** Component name (from filename) */
+    name: string;
+    /** Script content (instance script, if present) */
+    scriptContent: string | null;
+    /** Module-level script content (context="module", if present) */
+    moduleScriptContent: string | null;
+    /** Template markup (everything outside script/style blocks) */
+    templateContent: string;
+    /** Whether the file has scoped styles */
+    hasStyles: boolean;
+    /** Imports extracted from script blocks */
+    imports: ImportEdge[];
+    /** Props extracted from `export let` declarations */
+    props: PropInfo[];
+    /** Child components referenced in the template */
+    childComponents: string[];
+}
+/**
+ * Parse a Svelte file and extract component information.
+ */
+declare function parseSvelteFile(source: string, filePath: string): SvelteFileAnalysis;
+/**
+ * Convert a Svelte file analysis result to a ComponentInfo.
+ */
+declare function svelteFileToComponentInfo(analysis: SvelteFileAnalysis, filePath: string): ComponentInfo;
+
+export { type AnalysisStats, type ExportInfo, type FileAnalysis, type FunctionInfo, type JsxElementInfo, type ProjectAnalysis, type SvelteFileAnalysis, type VueSFCAnalysis, analyzeFile, analyzeProject, analyzeSource, createTypeChecker, crossReferenceComponents, detectComponents, extractAllPropsFromFile, extractPropsFromTsType, extractPropsFromType, parseSvelteFile, parseVueSFC, svelteFileToComponentInfo, vueSFCToComponentInfo };

package/dist/index.js

@@ -0,0 +1,822 @@
+// src/ast-scanner.ts
+import ts from "typescript";
+import { readFile } from "fs/promises";
+async function analyzeFile(filePath) {
+  const source = await readFile(filePath, "utf-8");
+  return analyzeSource(source, filePath);
+}
+function analyzeSource(source, filePath) {
+  const isJsx = filePath.endsWith(".tsx") || filePath.endsWith(".jsx");
+  const scriptKind = isJsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    // setParentNodes
+    scriptKind
+  );
+  const imports = [];
+  const exports = [];
+  const jsxElements = [];
+  const functionDeclarations = [];
+  let hasJsx = false;
+  function visit(node) {
+    if (ts.isImportDeclaration(node)) {
+      const edge = extractImport(node, filePath, sourceFile);
+      if (edge) imports.push(edge);
+    }
+    if (ts.isExportDeclaration(node)) {
+      const info = extractExportDeclaration(node, sourceFile);
+      if (info) exports.push(...info);
+    }
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      functionDeclarations.push(extractFunction(node, sourceFile));
+    }
+    if (ts.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name) && decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+          const isExported = hasExportModifier(node);
+          functionDeclarations.push(
+            extractArrowFunction(decl.name, decl.initializer, isExported, sourceFile)
+          );
+        }
+      }
+      if (hasExportModifier(node)) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name)) {
+            exports.push({
+              name: decl.name.text,
+              kind: "variable",
+              isDefault: false,
+              line: getLine(decl, sourceFile)
+            });
+          }
+        }
+      }
+    }
+    if (ts.isFunctionDeclaration(node) && node.name && hasExportModifier(node)) {
+      const isDefault = hasDefaultModifier(node);
+      exports.push({
+        name: node.name.text,
+        kind: "function",
+        isDefault,
+        line: getLine(node, sourceFile)
+      });
+    }
+    if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+      hasJsx = true;
+      jsxElements.push(extractJsxElement(node, sourceFile));
+    }
+    if (ts.isExportAssignment(node) && !node.isExportEquals && ts.isIdentifier(node.expression)) {
+      exports.push({
+        name: node.expression.text,
+        kind: "variable",
+        isDefault: true,
+        line: getLine(node, sourceFile)
+      });
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return {
+    filePath,
+    imports,
+    exports,
+    jsxElements,
+    functionDeclarations,
+    hasJsx
+  };
+}
+function extractImport(node, filePath, _sourceFile) {
+  if (!ts.isStringLiteral(node.moduleSpecifier)) return null;
+  const target = node.moduleSpecifier.text;
+  const specifiers = [];
+  const typeOnly = node.importClause?.isTypeOnly ?? false;
+  const clause = node.importClause;
+  if (clause) {
+    if (clause.name) {
+      specifiers.push({
+        imported: "default",
+        local: clause.name.text
+      });
+    }
+    if (clause.namedBindings) {
+      if (ts.isNamedImports(clause.namedBindings)) {
+        for (const el of clause.namedBindings.elements) {
+          specifiers.push({
+            imported: el.propertyName?.text ?? el.name.text,
+            local: el.name.text
+          });
+        }
+      }
+      if (ts.isNamespaceImport(clause.namedBindings)) {
+        specifiers.push({
+          imported: "*",
+          local: clause.namedBindings.name.text
+        });
+      }
+    }
+  }
+  return { source: filePath, target, specifiers, typeOnly };
+}
+function extractExportDeclaration(node, sourceFile) {
+  const results = [];
+  if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+    for (const el of node.exportClause.elements) {
+      results.push({
+        name: el.name.text,
+        kind: "re-export",
+        isDefault: false,
+        line: getLine(el, sourceFile)
+      });
+    }
+  }
+  return results.length > 0 ? results : null;
+}
+function extractFunction(node, sourceFile) {
+  return {
+    name: node.name?.text ?? "<anonymous>",
+    line: getLine(node, sourceFile),
+    returnsJsx: containsJsx(node),
+    parameters: extractParameters(node),
+    isExported: hasExportModifier(node),
+    isDefault: hasDefaultModifier(node),
+    isArrowFunction: false
+  };
+}
+function extractArrowFunction(name, initializer, isExported, sourceFile) {
+  return {
+    name: name.text,
+    line: getLine(name, sourceFile),
+    returnsJsx: containsJsx(initializer),
+    parameters: extractParameters(initializer),
+    isExported,
+    isDefault: false,
+    isArrowFunction: ts.isArrowFunction(initializer)
+  };
+}
+function extractJsxElement(node, sourceFile) {
+  const tagName = node.tagName.getText(sourceFile);
+  const isComponent = /^[A-Z]/.test(tagName);
+  const props = [];
+  for (const attr of node.attributes.properties) {
+    if (ts.isJsxAttribute(attr) && attr.name) {
+      props.push(attr.name.getText(sourceFile));
+    }
+  }
+  return {
+    tagName,
+    isComponent,
+    line: getLine(node, sourceFile),
+    props
+  };
+}
+function extractParameters(node) {
+  return node.parameters.map((param) => ({
+    name: param.name.getText(),
+    type: param.type?.getText() ?? "unknown"
+  }));
+}
+function containsJsx(node) {
+  let found = false;
+  function walk(n) {
+    if (ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n) || ts.isJsxFragment(n)) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(n, walk);
+  }
+  walk(node);
+  return found;
+}
+function hasExportModifier(node) {
+  if (!ts.canHaveModifiers(node)) return false;
+  const modifiers = ts.getModifiers(node);
+  return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function hasDefaultModifier(node) {
+  if (!ts.canHaveModifiers(node)) return false;
+  const modifiers = ts.getModifiers(node);
+  return modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
+}
+function getLine(node, sourceFile) {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+
+// src/component-detector.ts
+function detectComponents(analysis, framework) {
+  const components = [];
+  for (const fn of analysis.functionDeclarations) {
+    if (isLikelyComponent(fn, analysis, framework)) {
+      components.push(toComponentInfo(fn, analysis, framework));
+    }
+  }
+  return components;
+}
+function isLikelyComponent(fn, _analysis, framework) {
+  if (!/^[A-Z]/.test(fn.name)) return false;
+  switch (framework) {
+    case "react":
+      return fn.returnsJsx;
+    case "vue":
+      return fn.returnsJsx;
+    case "svelte":
+      return fn.returnsJsx;
+    default:
+      return fn.returnsJsx && fn.isExported;
+  }
+}
+function toComponentInfo(fn, analysis, framework) {
+  const id = `${analysis.filePath}#${fn.name}`;
+  let exportKind = "named";
+  const exp = analysis.exports.find((e) => e.name === fn.name);
+  if (exp?.isDefault) {
+    exportKind = "default";
+  } else if (exp?.kind === "re-export") {
+    exportKind = "re-export";
+  }
+  const props = extractProps(fn);
+  const children = analysis.jsxElements.filter((el) => el.isComponent).map((el) => el.tagName);
+  const dependencies = analysis.imports.filter((imp) => !imp.target.startsWith(".") && !imp.target.startsWith("/")).map((imp) => imp.target);
+  return {
+    id,
+    name: fn.name,
+    filePath: analysis.filePath,
+    line: fn.line,
+    framework,
+    exportKind,
+    props,
+    children: [...new Set(children)],
+    usedBy: [],
+    // Populated later by cross-file analysis
+    dependencies: [...new Set(dependencies)],
+    metadata: {}
+  };
+}
+function extractProps(fn) {
+  if (fn.parameters.length === 0) return [];
+  const firstParam = fn.parameters[0];
+  if (!firstParam) return [];
+  return [
+    {
+      name: firstParam.name,
+      type: firstParam.type,
+      required: true,
+      description: "Auto-detected parameter \u2014 full prop extraction requires type analysis"
+    }
+  ];
+}
+function crossReferenceComponents(components) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const comp of components) {
+    byName.set(comp.name, comp);
+  }
+  for (const comp of components) {
+    for (const childName of comp.children) {
+      const child = byName.get(childName);
+      if (child && !child.usedBy.includes(comp.id)) {
+        child.usedBy.push(comp.id);
+      }
+    }
+  }
+  for (const comp of components) {
+    comp.children = comp.children.map((name) => byName.get(name)?.id ?? name).filter(Boolean);
+  }
+  return components;
+}
+
+// src/prop-extractor.ts
+import ts2 from "typescript";
+function createTypeChecker(filePaths, compilerOptions) {
+  const options = {
+    target: ts2.ScriptTarget.ES2022,
+    module: ts2.ModuleKind.Node16,
+    moduleResolution: ts2.ModuleResolutionKind.Node16,
+    jsx: ts2.JsxEmit.ReactJSX,
+    strict: true,
+    noEmit: true,
+    skipLibCheck: true,
+    ...compilerOptions
+  };
+  const program = ts2.createProgram(filePaths, options);
+  return program.getTypeChecker();
+}
+function extractPropsFromType(checker, node) {
+  const firstParam = node.parameters[0];
+  if (!firstParam) return [];
+  const paramType = checker.getTypeAtLocation(firstParam);
+  return extractPropsFromTsType(checker, paramType);
+}
+function extractPropsFromTsType(checker, type) {
+  const props = [];
+  const properties = type.getProperties();
+  for (const prop of properties) {
+    if (isInternalProp(prop.name)) continue;
+    const propType = checker.getTypeOfSymbol(prop);
+    const typeString = checker.typeToString(propType, void 0, ts2.TypeFormatFlags.NoTruncation);
+    const isOptional = (prop.flags & ts2.SymbolFlags.Optional) !== 0;
+    const defaultValue = getDefaultValue(prop);
+    const description = getJSDocDescription(prop);
+    props.push({
+      name: prop.name,
+      type: typeString,
+      required: !isOptional && defaultValue === void 0,
+      defaultValue,
+      description
+    });
+  }
+  return props;
+}
+function extractAllPropsFromFile(checker, sourceFile) {
+  const result = /* @__PURE__ */ new Map();
+  function visit(node) {
+    if (ts2.isFunctionDeclaration(node) && node.name) {
+      const name = node.name.text;
+      if (/^[A-Z]/.test(name) && node.parameters.length > 0) {
+        const props = extractPropsFromType(checker, node);
+        if (props.length > 0) {
+          result.set(name, props);
+        }
+      }
+    }
+    if (ts2.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (ts2.isIdentifier(decl.name) && /^[A-Z]/.test(decl.name.text) && decl.initializer && (ts2.isArrowFunction(decl.initializer) || ts2.isFunctionExpression(decl.initializer))) {
+          const fn = decl.initializer;
+          if (fn.parameters.length > 0) {
+            const props = extractPropsFromType(checker, fn);
+            if (props.length > 0) {
+              result.set(decl.name.text, props);
+            }
+          }
+        }
+      }
+    }
+    ts2.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function isInternalProp(name) {
+  const internals = /* @__PURE__ */ new Set([
+    "key",
+    "ref",
+    "children"
+    // Often included but worth keeping — make configurable later
+  ]);
+  return internals.has(name);
+}
+function getDefaultValue(symbol) {
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0) return void 0;
+  for (const decl of declarations) {
+    if (ts2.isBindingElement(decl) && decl.initializer) {
+      return decl.initializer.getText();
+    }
+  }
+  return void 0;
+}
+function getJSDocDescription(symbol) {
+  const docs = symbol.getDocumentationComment(void 0);
+  if (docs.length === 0) return void 0;
+  return docs.map((d) => d.text).join("\n");
+}
+
+// src/project-analyzer.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { resolve, relative } from "path";
+import ts3 from "typescript";
+import {
+  ComponentRegistry,
+  DependencyGraph,
+  loadConfig
+} from "@foxlight/core";
+
+// src/frameworks/vue-parser.ts
+import { extractImportsFromScript } from "@foxlight/core";
+function parseVueSFC(source, filePath) {
+  const name = extractComponentName(filePath);
+  const scriptContent = extractBlock(source, "script");
+  const isScriptSetup = /<script[^>]*\bsetup\b/.test(source);
+  const templateContent = extractBlock(source, "template");
+  const hasScopedStyles = /<style[^>]*\bscoped\b/.test(source);
+  const imports = scriptContent ? extractImportsFromScript(scriptContent, filePath) : [];
+  const props = scriptContent ? extractPropsFromScript(scriptContent, isScriptSetup) : [];
+  const childComponents = templateContent ? extractChildComponentsFromTemplate(templateContent) : [];
+  return {
+    name,
+    scriptContent,
+    isScriptSetup,
+    templateContent,
+    hasScopedStyles,
+    imports,
+    props,
+    childComponents
+  };
+}
+function vueSFCToComponentInfo(analysis, filePath) {
+  return {
+    id: `${filePath}#${analysis.name}`,
+    name: analysis.name,
+    filePath,
+    line: 1,
+    framework: "vue",
+    exportKind: "default",
+    props: analysis.props,
+    children: analysis.childComponents,
+    usedBy: [],
+    dependencies: analysis.imports.filter((imp) => !imp.target.startsWith(".") && !imp.target.startsWith("/")).map((imp) => imp.target),
+    metadata: {
+      isScriptSetup: analysis.isScriptSetup,
+      hasScopedStyles: analysis.hasScopedStyles
+    }
+  };
+}
+function extractBlock(source, tag) {
+  const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "i");
+  const match = source.match(regex);
+  return match?.[1]?.trim() ?? null;
+}
+function extractComponentName(filePath) {
+  const fileName = filePath.split("/").pop() ?? "Unknown";
+  const baseName = fileName.replace(/\.vue$/, "");
+  return baseName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function extractPropsFromScript(script, isScriptSetup) {
+  if (isScriptSetup) {
+    return extractDefineProps(script);
+  }
+  return extractOptionsAPIProps(script);
+}
+function extractDefineProps(script) {
+  const objectMatch = script.match(/defineProps\(\s*\{([^}]+)\}\s*\)/);
+  if (objectMatch?.[1]) {
+    return parseObjectProps(objectMatch[1]);
+  }
+  const genericMatch = script.match(/defineProps<\s*\{([^}]+)\}\s*>\(\)/);
+  if (genericMatch?.[1]) {
+    return parseTypeProps(genericMatch[1]);
+  }
+  return [];
+}
+function extractOptionsAPIProps(script) {
+  const propsMatch = script.match(/props\s*:\s*\{([^}]+)\}/);
+  if (!propsMatch?.[1]) return [];
+  return parseObjectProps(propsMatch[1]);
+}
+function parseObjectProps(content) {
+  const props = [];
+  const entries = content.split(",").map((s) => s.trim()).filter(Boolean);
+  for (const entry of entries) {
+    const colonIdx = entry.indexOf(":");
+    if (colonIdx === -1) {
+      props.push({
+        name: entry.trim(),
+        type: "unknown",
+        required: false
+      });
+    } else {
+      const name = entry.slice(0, colonIdx).trim();
+      const typeStr = entry.slice(colonIdx + 1).trim();
+      props.push({
+        name,
+        type: typeStr,
+        required: typeStr.includes("required") || !typeStr.includes("?")
+      });
+    }
+  }
+  return props;
+}
+function parseTypeProps(content) {
+  const props = [];
+  const entries = content.split(/[;\n]/).map((s) => s.trim()).filter(Boolean);
+  for (const entry of entries) {
+    const match = entry.match(/(\w+)(\?)?:\s*(.+)/);
+    if (match) {
+      props.push({
+        name: match[1],
+        type: match[3].trim().replace(/;$/, ""),
+        required: !match[2]
+      });
+    }
+  }
+  return props;
+}
+function extractChildComponentsFromTemplate(template) {
+  const components = /* @__PURE__ */ new Set();
+  const pascalRegex = /<([A-Z][a-zA-Z0-9]+)/g;
+  let match;
+  while ((match = pascalRegex.exec(template)) !== null) {
+    components.add(match[1]);
+  }
+  const kebabRegex = /<([a-z]+-[a-z-]+)/g;
+  while ((match = kebabRegex.exec(template)) !== null) {
+    const pascal = match[1].split("-").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+    components.add(pascal);
+  }
+  return Array.from(components);
+}
+
+// src/frameworks/svelte-parser.ts
+import { extractImportsFromScript as extractImportsFromScript2 } from "@foxlight/core";
+function parseSvelteFile(source, filePath) {
+  const name = extractComponentName2(filePath);
+  const scriptContent = extractInstanceScript(source);
+  const moduleScriptContent = extractModuleScript(source);
+  const templateContent = extractTemplateContent(source);
+  const hasStyles = /<style[\s>]/.test(source);
+  const allScriptContent = [moduleScriptContent, scriptContent].filter(Boolean).join("\n");
+  const imports = allScriptContent ? extractImportsFromScript2(allScriptContent, filePath) : [];
+  const props = scriptContent ? extractExportLetProps(scriptContent) : [];
+  const childComponents = extractChildComponentsFromTemplate2(templateContent);
+  return {
+    name,
+    scriptContent,
+    moduleScriptContent,
+    templateContent,
+    hasStyles,
+    imports,
+    props,
+    childComponents
+  };
+}
+function svelteFileToComponentInfo(analysis, filePath) {
+  return {
+    id: `${filePath}#${analysis.name}`,
+    name: analysis.name,
+    filePath,
+    line: 1,
+    framework: "svelte",
+    exportKind: "default",
+    props: analysis.props,
+    children: analysis.childComponents,
+    usedBy: [],
+    dependencies: analysis.imports.filter((imp) => !imp.target.startsWith(".") && !imp.target.startsWith("/")).map((imp) => imp.target),
+    metadata: {
+      hasModuleScript: analysis.moduleScriptContent !== null,
+      hasStyles: analysis.hasStyles
+    }
+  };
+}
+function extractComponentName2(filePath) {
+  const fileName = filePath.split("/").pop() ?? "Unknown";
+  const baseName = fileName.replace(/\.svelte$/, "");
+  return baseName.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function extractInstanceScript(source) {
+  const regex = /<script(?![^>]*context\s*=\s*["']module["'])[^>]*>([\s\S]*?)<\/script>/i;
+  const match = source.match(regex);
+  return match?.[1]?.trim() ?? null;
+}
+function extractModuleScript(source) {
+  const regex = /<script[^>]*context\s*=\s*["']module["'][^>]*>([\s\S]*?)<\/script>/i;
+  const match = source.match(regex);
+  return match?.[1]?.trim() ?? null;
+}
+function extractTemplateContent(source) {
+  return source.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").trim();
+}
+function extractExportLetProps(script) {
+  const props = [];
+  const exportLetRegex = /export\s+let\s+(\w+)\s*(?::\s*([^=;\n]+?))?\s*(?:=\s*([^;\n]+?))?\s*[;\n]/g;
+  let match;
+  while ((match = exportLetRegex.exec(script)) !== null) {
+    const name = match[1];
+    const typeAnnotation = match[2]?.trim();
+    const defaultValue = match[3]?.trim();
+    const required = defaultValue === void 0;
+    let type = typeAnnotation ?? "unknown";
+    if (type === "unknown" && defaultValue !== void 0) {
+      type = inferTypeFromDefault(defaultValue);
+    }
+    props.push({
+      name,
+      type,
+      required,
+      defaultValue
+    });
+  }
+  return props;
+}
+function inferTypeFromDefault(value) {
+  if (value === "true" || value === "false") return "boolean";
+  if (/^['"]/.test(value)) return "string";
+  if (/^-?\d+(\.\d+)?$/.test(value)) return "number";
+  if (value.startsWith("[")) return "array";
+  if (value.startsWith("{")) return "object";
+  if (value === "null") return "null";
+  if (value === "undefined") return "undefined";
+  return "unknown";
+}
+function extractChildComponentsFromTemplate2(template) {
+  const components = /* @__PURE__ */ new Set();
+  const pascalRegex = /<([A-Z][a-zA-Z0-9]+)/g;
+  let match;
+  while ((match = pascalRegex.exec(template)) !== null) {
+    components.add(match[1]);
+  }
+  return Array.from(components);
+}
+
+// src/project-analyzer.ts
+async function analyzeProject(rootDir, configOverrides) {
+  const startTime = performance.now();
+  const config = {
+    ...await loadConfig(rootDir),
+    ...configOverrides
+  };
+  const framework = config.framework ?? "unknown";
+  const files = await findSourceFiles(config);
+  const registry = new ComponentRegistry();
+  const allImports = [];
+  let totalComponents = 0;
+  for (const filePath of files) {
+    try {
+      if (filePath.endsWith(".vue")) {
+        const source = await readFile2(filePath, "utf-8");
+        const vueAnalysis = parseVueSFC(source, filePath);
+        const component = vueSFCToComponentInfo(vueAnalysis, filePath);
+        registry.addComponents([component]);
+        totalComponents += 1;
+        if (vueAnalysis.scriptContent) {
+          const scriptAnalysis = analyzeSource(vueAnalysis.scriptContent, filePath);
+          registry.addImports(scriptAnalysis.imports);
+          allImports.push(...scriptAnalysis.imports);
+        }
+        if (vueAnalysis.imports.length > 0) {
+          registry.addImports(vueAnalysis.imports);
+          allImports.push(...vueAnalysis.imports);
+        }
+        continue;
+      }
+      if (filePath.endsWith(".svelte")) {
+        const source = await readFile2(filePath, "utf-8");
+        const svelteAnalysis = parseSvelteFile(source, filePath);
+        const component = svelteFileToComponentInfo(svelteAnalysis, filePath);
+        registry.addComponents([component]);
+        totalComponents += 1;
+        const scriptContent = [svelteAnalysis.moduleScriptContent, svelteAnalysis.scriptContent].filter(Boolean).join("\n");
+        if (scriptContent) {
+          const scriptAnalysis = analyzeSource(scriptContent, filePath);
+          registry.addImports(scriptAnalysis.imports);
+          allImports.push(...scriptAnalysis.imports);
+        }
+        if (svelteAnalysis.imports.length > 0) {
+          registry.addImports(svelteAnalysis.imports);
+          allImports.push(...svelteAnalysis.imports);
+        }
+        continue;
+      }
+      const analysis = await analyzeFile(filePath);
+      registry.addImports(analysis.imports);
+      allImports.push(...analysis.imports);
+      const components = detectComponents(analysis, framework);
+      if (components.length > 0) {
+        registry.addComponents(components);
+        totalComponents += components.length;
+      }
+    } catch (error) {
+      console.warn(`[foxlight] Warning: Failed to analyze ${filePath}:`, error);
+    }
+  }
+  const allComponents = registry.getAllComponents();
+  const crossReferenced = crossReferenceComponents(allComponents);
+  registry.clear();
+  registry.addComponents(crossReferenced);
+  registry.addImports(allImports);
+  try {
+    const program = ts3.createProgram(files, {
+      target: ts3.ScriptTarget.ES2022,
+      module: ts3.ModuleKind.Node16,
+      moduleResolution: ts3.ModuleResolutionKind.Node16,
+      jsx: ts3.JsxEmit.ReactJSX,
+      strict: true,
+      noEmit: true,
+      skipLibCheck: true
+    });
+    const checker = program.getTypeChecker();
+    for (const filePath of files) {
+      const sourceFile = program.getSourceFile(filePath);
+      if (!sourceFile) continue;
+      const fileProps = extractAllPropsFromFile(checker, sourceFile);
+      for (const [componentName, props] of fileProps) {
+        const comp = registry.getAllComponents().find((c) => c.name === componentName && c.filePath === filePath);
+        if (comp && props.length > 0) {
+          comp.props = props;
+        }
+      }
+    }
+  } catch {
+  }
+  const graph = DependencyGraph.fromImports(allImports);
+  const duration = performance.now() - startTime;
+  return {
+    config,
+    registry,
+    graph,
+    stats: {
+      filesScanned: files.length,
+      componentsFound: totalComponents,
+      importsTracked: allImports.length,
+      duration
+    }
+  };
+}
+async function findSourceFiles(config) {
+  const rootDir = resolve(config.rootDir);
+  const allFiles = await walkDir(rootDir);
+  const includeMatchers = config.include.map((p) => createGlobMatcher(p));
+  const excludeMatchers = config.exclude.map((p) => createGlobMatcher(p));
+  return allFiles.filter((filePath) => {
+    const rel = relative(rootDir, filePath);
+    const included = includeMatchers.some((matcher) => matcher(rel));
+    if (!included) return false;
+    const excluded = excludeMatchers.some((matcher) => matcher(rel));
+    return !excluded;
+  });
+}
+function createGlobMatcher(pattern) {
+  const regexStr = globToRegex(pattern);
+  const regex = new RegExp(`^${regexStr}$`, "i");
+  return (path) => regex.test(path);
+}
+function globToRegex(pattern) {
+  let result = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const char = pattern[i];
+    if (char === "*") {
+      if (pattern[i + 1] === "*") {
+        if (pattern[i + 2] === "/") {
+          result += "(?:.+/)?";
+          i += 3;
+        } else {
+          result += ".*";
+          i += 2;
+        }
+      } else {
+        result += "[^/]*";
+        i++;
+      }
+    } else if (char === "?") {
+      result += "[^/]";
+      i++;
+    } else if (char === "{") {
+      const closeIdx = pattern.indexOf("}", i);
+      if (closeIdx === -1) {
+        result += "\\{";
+        i++;
+      } else {
+        const alternatives = pattern.slice(i + 1, closeIdx).split(",");
+        result += `(?:${alternatives.map(escapeRegex).join("|")})`;
+        i = closeIdx + 1;
+      }
+    } else if (char === ".") {
+      result += "\\.";
+      i++;
+    } else {
+      result += escapeRegexChar(char);
+      i++;
+    }
+  }
+  return result;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeRegexChar(char) {
+  return /[.*+?^${}()|[\]\\]/.test(char) ? `\\${char}` : char;
+}
+async function walkDir(dir) {
+  const results = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = resolve(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git") continue;
+        results.push(...await walkDir(fullPath));
+      } else {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+export {
+  analyzeFile,
+  analyzeProject,
+  analyzeSource,
+  createTypeChecker,
+  crossReferenceComponents,
+  detectComponents,
+  extractAllPropsFromFile,
+  extractPropsFromTsType,
+  extractPropsFromType,
+  parseSvelteFile,
+  parseVueSFC,
+  svelteFileToComponentInfo,
+  vueSFCToComponentInfo
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@foxlight/analyzer",
+  "version": "0.1.0",
+  "description": "Static analysis engine for Foxlight — AST scanning, component detection, import resolution.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "@foxlight/core": "*"
+  },
+  "peerDependencies": {
+    "typescript": "^5.4.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": false
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "author": "Jose Cruz",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/josegabrielcruz/foxlight.git",
+    "directory": "packages/analyzer"
+  },
+  "homepage": "https://github.com/josegabrielcruz/foxlight/tree/master/packages/analyzer#readme",
+  "bugs": {
+    "url": "https://github.com/josegabrielcruz/foxlight/issues"
+  },
+  "keywords": [
+    "foxlight",
+    "static-analysis",
+    "ast",
+    "component-detection",
+    "typescript",
+    "vue",
+    "svelte"
+  ]
+}