@abhinav2203/codeflow-core 0.1.0 → 1.0.0

package/dist/analyzer/build.d.ts

@@ -1,2 +1,2 @@
-import type { BlueprintGraph, BuildBlueprintRequest } from "../schema/index";
+import type { BlueprintGraph, BuildBlueprintRequest } from "../schema/index.js";
 export declare const buildBlueprintGraph: (request: BuildBlueprintRequest) => Promise<BlueprintGraph>;

package/dist/analyzer/build.js

@@ -1,13 +1,13 @@
 import path from "node:path";
-import { emptyContract } from "../schema/index";
-import { parsePrd } from "../internal/prd";
-import { withSpecDrafts } from "../internal/phases";
-import { analyzeTypeScriptRepo } from "./repo";
-import { createNode, dedupeEdges, mergeContracts, mergeSourceRefs } from "../internal/utils";
+import { emptyContract } from "../schema/index.js";
+import { parsePrd } from "../internal/prd.js";
+import { withSpecDrafts } from "../internal/phases.js";
+import { analyzeTypeScriptRepo } from "./repo.js";
+import { createNode, dedupeEdges, mergeContracts, mergeSourceRefs } from "../internal/utils.js";
 const mergeNodes = (nodes) => {
     const map = new Map();
     for (const node of nodes) {
-        const dedupeKey = `${node.kind}:${node.path ?? node.name}`;
+        const dedupeKey = `${node.kind}:${node.path ?? ""}:${node.name}`;
         const existing = map.get(dedupeKey);
         if (!existing) {
             map.set(dedupeKey, node);

package/dist/analyzer/index.d.ts

@@ -1,2 +1,4 @@
-export { buildBlueprintGraph } from "./build";
-export { analyzeTypeScriptRepo } from "./repo";
+export { buildBlueprintGraph } from "./build.js";
+export { analyzeTypeScriptRepo } from "./repo.js";
+export { analyzeRepo } from "./repo-multi.js";
+export type { AnalyzeRepoOptions } from "./repo-multi.js";

package/dist/analyzer/index.js

@@ -1,2 +1,3 @@
-export { buildBlueprintGraph } from "./build";
-export { analyzeTypeScriptRepo } from "./repo";
+export { buildBlueprintGraph } from "./build.js";
+export { analyzeTypeScriptRepo } from "./repo.js";
+export { analyzeRepo } from "./repo-multi.js";

package/dist/analyzer/repo-multi.d.ts

@@ -0,0 +1,6 @@
+type RepoGraphPart = Omit<import("../schema/index.js").BlueprintGraph, "projectName" | "mode" | "generatedAt">;
+export interface AnalyzeRepoOptions {
+    excludePatterns?: string[];
+}
+export declare const analyzeRepo: (repoPath: string, options?: AnalyzeRepoOptions) => Promise<RepoGraphPart>;
+export {};

package/dist/analyzer/repo-multi.js

@@ -0,0 +1,246 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { emptyContract } from "../schema/index.js";
+import { createNode, dedupeEdges, mergeContracts, toPosixPath } from "../internal/utils.js";
+import { SUPPORTED_EXTENSIONS } from "./tree-sitter-loader.js";
+import { extractNodesFromFile } from "./tree-sitter-analyzer.js";
+const DEFAULT_EXCLUDE_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "target",
+    "__pycache__",
+    "vendor",
+    ".venv"
+]);
+const SOURCE_EXTENSIONS = new Set([
+    ".ts", ".tsx", ".js", ".jsx",
+    ".go", ".py",
+    ".c", ".cpp", ".cc", ".cxx", ".h", ".hpp",
+    ".rs"
+]);
+const walkDirectory = async (dir, excludeDirs) => {
+    const files = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (excludeDirs.has(entry.name))
+                continue;
+            files.push(...await walkDirectory(fullPath, excludeDirs));
+        }
+        else if (entry.isFile()) {
+            const ext = path.extname(entry.name);
+            if (SOURCE_EXTENSIONS.has(ext)) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files;
+};
+export const analyzeRepo = async (repoPath, options) => {
+    const repoStat = await fs.stat(repoPath).catch(() => null);
+    if (!repoStat?.isDirectory()) {
+        throw new Error(`Repo path does not exist or is not a directory: ${repoPath}`);
+    }
+    const excludeDirs = new Set(DEFAULT_EXCLUDE_DIRS);
+    if (options?.excludePatterns) {
+        for (const p of options.excludePatterns)
+            excludeDirs.add(p);
+    }
+    const files = await walkDirectory(repoPath, excludeDirs);
+    const warnings = [];
+    if (files.length === 0) {
+        warnings.push(`No supported source files found under ${repoPath}. Supported: ${[...SOURCE_EXTENSIONS].join(", ")}`);
+    }
+    const allNodes = [];
+    const allSymbolIndex = new Map();
+    const allCallEdges = [];
+    const allImportEdges = [];
+    const allInheritEdges = [];
+    for (const filePath of files) {
+        const relativePath = toPosixPath(path.relative(repoPath, filePath));
+        const result = await extractNodesFromFile(filePath, relativePath);
+        allNodes.push(...result.nodes);
+        for (const [key, id] of result.symbolIndex) {
+            allSymbolIndex.set(key, id);
+        }
+        allCallEdges.push(...result.callEdges);
+        allImportEdges.push(...result.importEdges);
+        allInheritEdges.push(...result.inheritEdges);
+    }
+    const nodeMap = new Map();
+    for (const n of allNodes) {
+        nodeMap.set(n.nodeId, createNode({
+            id: n.nodeId,
+            kind: n.kind,
+            name: n.name,
+            summary: n.summary,
+            path: n.path,
+            ownerId: n.ownerId,
+            signature: n.signature || undefined,
+            contract: mergeContracts(emptyContract(), {
+                ...emptyContract(),
+                summary: n.summary,
+                responsibilities: [n.summary]
+            }),
+            sourceRefs: n.sourceRefs
+        }));
+    }
+    const edges = [];
+    // Build module lookup map for O(1) import resolution
+    const moduleLookup = new Map();
+    for (const node of nodeMap.values()) {
+        if (node.kind !== "module" || node.path == null)
+            continue;
+        const normalizedPath = toPosixPath(node.path);
+        const pathWithoutExtension = normalizedPath.slice(0, normalizedPath.length - path.extname(normalizedPath).length);
+        const basenameWithoutExtension = path.posix.basename(pathWithoutExtension);
+        // Map exact path
+        if (!moduleLookup.has(normalizedPath)) {
+            moduleLookup.set(normalizedPath, node);
+        }
+        // Map path without extension
+        if (!moduleLookup.has(pathWithoutExtension)) {
+            moduleLookup.set(pathWithoutExtension, node);
+        }
+        // Map basename without extension
+        if (!moduleLookup.has(basenameWithoutExtension)) {
+            moduleLookup.set(basenameWithoutExtension, node);
+        }
+    }
+    // Helper to build deterministic import candidate paths
+    const buildImportCandidatePaths = (fromModulePath, importPath) => {
+        const normalizedImportPath = toPosixPath(importPath);
+        const importerDir = path.posix.dirname(toPosixPath(fromModulePath));
+        const isRelativeImport = normalizedImportPath.startsWith("./") || normalizedImportPath.startsWith("../");
+        const basePath = isRelativeImport
+            ? path.posix.normalize(path.posix.join(importerDir, normalizedImportPath))
+            : path.posix.normalize(normalizedImportPath.replace(/^\/+/, ""));
+        const candidates = new Set();
+        const importExt = path.posix.extname(basePath);
+        // If import already has extension, use it directly
+        if (importExt) {
+            candidates.add(basePath);
+            return candidates;
+        }
+        // Try all supported extensions
+        for (const ext of SUPPORTED_EXTENSIONS) {
+            candidates.add(`${basePath}${ext}`);
+            candidates.add(path.posix.join(basePath, `index${ext}`));
+        }
+        return candidates;
+    };
+    // Match import edges to module nodes using deterministic path resolution
+    for (const imp of allImportEdges) {
+        const sourceModule = nodeMap.get(imp.fromModuleId);
+        if (sourceModule?.kind !== "module" || sourceModule.path == null) {
+            continue;
+        }
+        const candidatePaths = buildImportCandidatePaths(sourceModule.path, imp.importPath);
+        let targetModule = [...nodeMap.values()].find(n => n.kind === "module" && n.path != null && candidatePaths.has(toPosixPath(n.path)));
+        // Fallback: try module lookup map
+        if (!targetModule) {
+            const normalizedImport = imp.importPath.replace(/^\.\//, "").replace(/\.js$/, "");
+            targetModule = moduleLookup.get(normalizedImport);
+        }
+        if (targetModule) {
+            edges.push({
+                from: imp.fromModuleId,
+                to: targetModule.id,
+                kind: "imports",
+                label: imp.importPath,
+                required: true,
+                confidence: 0.9
+            });
+        }
+    }
+    for (const inh of allInheritEdges) {
+        // Get child node to extract its path
+        const childNode = nodeMap.get(inh.fromId);
+        if (!childNode || childNode.path == null) {
+            continue;
+        }
+        // Try exact match in same file first
+        let parentNodeId = allSymbolIndex.get(`${childNode.path}::${inh.toName}`);
+        // Fallback: search across all files
+        if (!parentNodeId) {
+            parentNodeId = [...allSymbolIndex.entries()].find(([key]) => key.endsWith(`::${inh.toName}`))?.[1];
+        }
+        if (parentNodeId) {
+            edges.push({
+                from: inh.fromId,
+                to: parentNodeId,
+                kind: "inherits",
+                required: true,
+                confidence: 0.95
+            });
+        }
+    }
+    for (const call of allCallEdges) {
+        const targetId = [...allSymbolIndex.entries()].find(([key]) => key.endsWith(`::${call.toName}`))?.[1];
+        if (targetId && targetId !== call.fromId) {
+            edges.push({
+                from: call.fromId,
+                to: targetId,
+                kind: "calls",
+                label: call.callText,
+                required: true,
+                confidence: 0.85
+            });
+            const caller = nodeMap.get(call.fromId);
+            const target = nodeMap.get(targetId);
+            if (caller && target) {
+                nodeMap.set(call.fromId, {
+                    ...caller,
+                    contract: mergeContracts(caller.contract, {
+                        ...emptyContract(),
+                        calls: [{ target: target.name, kind: "calls", description: call.callText }],
+                        dependencies: [target.name]
+                    })
+                });
+            }
+        }
+    }
+    // Post-process: link Go methods (extracted as standalone functions) to their struct types
+    for (const node of nodeMap.values()) {
+        if (node.kind === "function" && node.name.includes(".") && !node.ownerId) {
+            const [ownerName] = node.name.split(".");
+            const classNode = [...nodeMap.values()].find(c => c.kind === "class" && c.name === ownerName);
+            if (classNode) {
+                nodeMap.set(node.id, { ...node, ownerId: classNode.id });
+            }
+        }
+    }
+    // Post-process: aggregate methods into their owner class's contract
+    for (const node of nodeMap.values()) {
+        if (node.kind !== "function" || !node.ownerId)
+            continue;
+        const ownerNode = nodeMap.get(node.ownerId);
+        if (!ownerNode || ownerNode.kind !== "class")
+            continue;
+        const methodSpec = {
+            name: node.name.split(".").pop() || node.name,
+            signature: node.signature || undefined,
+            summary: node.summary,
+            inputs: node.contract.inputs,
+            outputs: node.contract.outputs,
+            sideEffects: node.contract.sideEffects,
+            calls: node.contract.calls
+        };
+        nodeMap.set(ownerNode.id, {
+            ...ownerNode,
+            contract: {
+                ...ownerNode.contract,
+                methods: [...ownerNode.contract.methods, methodSpec]
+            }
+        });
+    }
+    return {
+        nodes: [...nodeMap.values()],
+        edges: dedupeEdges(edges),
+        workflows: [],
+        warnings
+    };
+};

package/dist/analyzer/repo-multi.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/analyzer/repo-multi.test.js

@@ -0,0 +1,208 @@
+import { describe, it, expect, afterAll } from "vitest";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { analyzeRepo } from "./repo-multi.js";
+import { resetLoader } from "./tree-sitter-loader.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURES_DIR = path.resolve(__dirname, "../../test-fixtures");
+describe("analyzeRepo", () => {
+    afterAll(() => {
+        resetLoader();
+    });
+    describe("Go", () => {
+        it("extracts functions, classes, and calls from Go repo", async () => {
+            const result = await analyzeRepo(path.join(FIXTURES_DIR, "sample-go"));
+            const nodeNames = result.nodes.map(n => n.name);
+            const nodeKinds = new Map(result.nodes.map(n => [n.id, n.kind]));
+            // Module node
+            expect(result.nodes.some(n => n.kind === "module" && n.name === "main.go")).toBe(true);
+            // Function nodes
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "ProcessData")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "formatString")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "main")).toBe(true);
+            // Class (struct) node
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "UserService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "Database")).toBe(true);
+            // Methods
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.GetUser")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.SaveUser")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "Database.Connect")).toBe(true);
+            // All nodes have required fields
+            for (const node of result.nodes) {
+                expect(node.id).toBeDefined();
+                expect(node.kind).toBeDefined();
+                expect(node.name).toBeDefined();
+                expect(node.summary).toBeDefined();
+                expect(node.path).toBeDefined();
+                expect(node.sourceRefs).toBeDefined();
+                expect(node.sourceRefs.length).toBeGreaterThan(0);
+                expect(node.sourceRefs[0].kind).toBe("repo");
+            }
+            // Calls edges
+            const callEdges = result.edges.filter(e => e.kind === "calls");
+            expect(callEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("Python", () => {
+        it("extracts functions, classes, methods, and calls from Python repo", async () => {
+            const result = await analyzeRepo(path.join(FIXTURES_DIR, "sample-python"));
+            // Module node
+            expect(result.nodes.some(n => n.kind === "module" && n.name === "service.py")).toBe(true);
+            // Functions
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "load_config")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "process_data")).toBe(true);
+            // Classes
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "UserService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "BaseService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "TaskService")).toBe(true);
+            // Methods
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.get_user")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.save_user")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "TaskService.create_task")).toBe(true);
+            // Calls edges exist
+            const callEdges = result.edges.filter(e => e.kind === "calls");
+            expect(callEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("C", () => {
+        it("extracts functions and calls from C repo", async () => {
+            const result = await analyzeRepo(path.join(FIXTURES_DIR, "sample-c"));
+            // Module node
+            expect(result.nodes.some(n => n.kind === "module" && n.name === "main.c")).toBe(true);
+            // Functions
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "process_data")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "calculate_sum")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "print_result")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "main")).toBe(true);
+            // Calls edges
+            const callEdges = result.edges.filter(e => e.kind === "calls");
+            expect(callEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("C++", () => {
+        it("extracts classes, inheritance, methods, and calls from C++ repo", async () => {
+            const result = await analyzeRepo(path.join(FIXTURES_DIR, "sample-cpp"));
+            // Module
+            expect(result.nodes.some(n => n.kind === "module" && n.name === "main.cpp")).toBe(true);
+            // Classes
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "BaseService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "UserService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "TaskService")).toBe(true);
+            // Function
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "process_data")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "main")).toBe(true);
+            // Methods
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.getUser")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.saveUser")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "TaskService.createTask")).toBe(true);
+            // Inheritance edges
+            const inheritEdges = result.edges.filter(e => e.kind === "inherits");
+            expect(inheritEdges.length).toBeGreaterThan(0);
+            // Calls edges
+            const callEdges = result.edges.filter(e => e.kind === "calls");
+            expect(callEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("Rust", () => {
+        it("extracts structs, impl methods, and calls from Rust repo", async () => {
+            const result = await analyzeRepo(path.join(FIXTURES_DIR, "sample-rust"));
+            // Module
+            expect(result.nodes.some(n => n.kind === "module" && n.name === "main.rs")).toBe(true);
+            // Functions
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "process_data")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "calculate_total")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "main")).toBe(true);
+            // Structs/classes
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "UserService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "TaskService")).toBe(true);
+            // Methods
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.get_user")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.save_user")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "TaskService.create_task")).toBe(true);
+            // Calls edges
+            const callEdges = result.edges.filter(e => e.kind === "calls");
+            expect(callEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("TypeScript", () => {
+        it("extracts classes, inheritance, methods, imports, and calls from TS repo", async () => {
+            const result = await analyzeRepo(path.join(FIXTURES_DIR, "sample-ts"));
+            // Module nodes
+            expect(result.nodes.some(n => n.kind === "module" && n.name === "service.ts")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "module" && n.name === "base-service.ts")).toBe(true);
+            // Functions
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "processData")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "calculateSum")).toBe(true);
+            // Classes
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "UserService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "BaseService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "TaskService")).toBe(true);
+            // Methods
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.getUser")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.saveUser")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "TaskService.createTask")).toBe(true);
+            // Inheritance edges
+            const inheritEdges = result.edges.filter(e => e.kind === "inherits");
+            expect(inheritEdges.length).toBeGreaterThan(0);
+            // Calls edges
+            const callEdges = result.edges.filter(e => e.kind === "calls");
+            expect(callEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("JavaScript", () => {
+        it("extracts classes, inheritance, methods, and calls from JS repo", async () => {
+            const result = await analyzeRepo(path.join(FIXTURES_DIR, "sample-js"));
+            // Module nodes
+            expect(result.nodes.some(n => n.kind === "module" && n.name === "service.js")).toBe(true);
+            // Functions
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "processData")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "calculateSum")).toBe(true);
+            // Classes
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "UserService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "BaseService")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "class" && n.name === "TaskService")).toBe(true);
+            // Methods
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.getUser")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "UserService.saveUser")).toBe(true);
+            expect(result.nodes.some(n => n.kind === "function" && n.name === "TaskService.createTask")).toBe(true);
+            // Inheritance edges
+            const inheritEdges = result.edges.filter(e => e.kind === "inherits");
+            expect(inheritEdges.length).toBeGreaterThan(0);
+            // Calls edges
+            const callEdges = result.edges.filter(e => e.kind === "calls");
+            expect(callEdges.length).toBeGreaterThan(0);
+        });
+    });
+    describe("edge cases", () => {
+        it("throws for invalid path", async () => {
+            await expect(analyzeRepo("/nonexistent/path")).rejects.toThrow();
+        });
+        it("returns warnings for empty directory", async () => {
+            const emptyDir = path.join(FIXTURES_DIR, "empty-test-dir");
+            const fs = await import("node:fs/promises");
+            await fs.mkdir(emptyDir, { recursive: true });
+            const result = await analyzeRepo(emptyDir);
+            expect(result.warnings.length).toBeGreaterThan(0);
+            expect(result.nodes.length).toBe(0);
+            await fs.rmdir(emptyDir);
+        });
+        it("generates summaries from comments", async () => {
+            const result = await analyzeRepo(path.join(FIXTURES_DIR, "sample-go"));
+            const processDataNode = result.nodes.find(n => n.name === "ProcessData");
+            expect(processDataNode).toBeDefined();
+            expect(processDataNode.summary.length).toBeGreaterThan(0);
+            // Should contain the comment text
+            expect(processDataNode.summary.toLowerCase()).toContain("process");
+        });
+        it("excludes node_modules and other excluded dirs", async () => {
+            const testDir = path.join(FIXTURES_DIR, "sample-ts");
+            const fs = await import("node:fs/promises");
+            const nmDir = path.join(testDir, "node_modules");
+            await fs.mkdir(nmDir, { recursive: true });
+            await fs.writeFile(path.join(nmDir, "bad.ts"), "function badFunc() {}");
+            const result = await analyzeRepo(testDir);
+            expect(result.nodes.some(n => n.name.includes("node_modules"))).toBe(false);
+            await fs.rm(nmDir, { recursive: true, force: true });
+        });
+    });
+});

package/dist/analyzer/repo.d.ts

@@ -1,4 +1,4 @@
-import type { BlueprintGraph } from "../schema/index";
+import type { BlueprintGraph } from "../schema/index.js";
 type RepoGraphPart = Omit<BlueprintGraph, "projectName" | "mode" | "generatedAt">;
 export declare const analyzeTypeScriptRepo: (repoPath: string) => Promise<RepoGraphPart>;
 export {};

package/dist/analyzer/repo.js

@@ -1,8 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
-import { emptyContract } from "../schema/index";
-import { createNode, createNodeId, dedupeEdges, mergeContracts, mergeDesignCalls, toPosixPath } from "../internal/utils";
+import { emptyContract } from "../schema/index.js";
+import { createNode, createNodeId, dedupeEdges, mergeContracts, mergeDesignCalls, toPosixPath } from "../internal/utils.js";
 const HTTP_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
 const EXCLUDED_SEGMENTS = ["/node_modules/", "/.next/", "/dist/", "/artifacts/", "/coverage/"];
 const hasJsDocSummary = (node) => {

package/dist/analyzer/test-hook-check.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/analyzer/test-hook-check.js

@@ -0,0 +1,2 @@
+export {};
+// test

package/dist/analyzer/tree-sitter-analyzer.d.ts

@@ -0,0 +1,34 @@
+import type { BlueprintEdge, BlueprintNodeKind } from "../schema/index.js";
+interface ExtractedNode {
+    nodeId: string;
+    kind: BlueprintNodeKind;
+    name: string;
+    summary: string;
+    path: string;
+    signature: string;
+    sourceRefs: Array<{
+        kind: "repo";
+        path: string;
+        symbol?: string;
+    }>;
+    ownerId?: string;
+}
+export declare const extractNodesFromFile: (filePath: string, relativePath: string) => Promise<{
+    nodes: ExtractedNode[];
+    edges: BlueprintEdge[];
+    symbolIndex: Map<string, string>;
+    callEdges: Array<{
+        fromId: string;
+        toName: string;
+        callText: string;
+    }>;
+    importEdges: Array<{
+        fromModuleId: string;
+        importPath: string;
+    }>;
+    inheritEdges: Array<{
+        fromId: string;
+        toName: string;
+    }>;
+}>;
+export {};