@abhinav2203/codeflow-analysis 0.1.0 → 0.1.1

package/dist/app/api/analysis/cycles/route.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=route.test.d.ts.map

package/dist/app/api/analysis/cycles/route.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.test.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/analysis/cycles/route.test.ts"],"names":[],"mappings":""}

package/dist/app/api/analysis/cycles/route.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { POST } from "../../../../handlers/cycles";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
+const minimalNode = (id) => ({
+    id,
+    kind: "function",
+    name: id,
+    summary: "A node.",
+    contract: emptyContract(),
+    sourceRefs: [],
+    generatedRefs: [],
+    traceRefs: [],
+});
+const minimalEdge = (from, to) => ({
+    from,
+    to,
+    kind: "calls",
+    required: true,
+    confidence: 1,
+});
+const baseGraph = {
+    projectName: "Cycles Route Test",
+    mode: "essential",
+    generatedAt: "2026-03-14T00:00:00.000Z",
+    warnings: [],
+    workflows: [],
+    nodes: [],
+    edges: [],
+};
+describe("POST /api/analysis/cycles", () => {
+    it("returns a cycle report with no cycles for a clean DAG", async () => {
+        const graph = {
+            ...baseGraph,
+            nodes: [minimalNode("function:a"), minimalNode("function:b"), minimalNode("function:c")],
+            edges: [minimalEdge("function:a", "function:b"), minimalEdge("function:b", "function:c")],
+        };
+        const response = await POST(new Request("http://localhost/api/analysis/cycles", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(graph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.report.totalCycles).toBe(0);
+        expect(body.report.hasCycles).toBe(false);
+    });
+    it("detects a cycle between two mutually dependent nodes", async () => {
+        const graph = {
+            ...baseGraph,
+            nodes: [minimalNode("function:a"), minimalNode("function:b")],
+            edges: [minimalEdge("function:a", "function:b"), minimalEdge("function:b", "function:a")],
+        };
+        const response = await POST(new Request("http://localhost/api/analysis/cycles", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(graph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.report.totalCycles).toBe(1);
+        expect(body.report.affectedNodeIds).toContain("function:a");
+        expect(body.report.affectedNodeIds).toContain("function:b");
+        expect(body.report.hasCycles).toBe(true);
+        expect(body.report.analyzedAt).toBeTruthy();
+    });
+    it("detects a self-loop as a cycle", async () => {
+        const graph = {
+            ...baseGraph,
+            nodes: [minimalNode("function:a")],
+            edges: [{ from: "function:a", to: "function:a", kind: "calls", required: true, confidence: 1 }],
+        };
+        const response = await POST(new Request("http://localhost/api/analysis/cycles", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(graph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.report.totalCycles).toBe(1);
+        expect(body.report.hasCycles).toBe(true);
+    });
+    it("returns 400 for an invalid request body", async () => {
+        const response = await POST(new Request("http://localhost/api/analysis/cycles", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ invalid: true }),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(400);
+        expect(body.error).toBeTruthy();
+    });
+});

package/dist/app/api/analysis/metrics/route.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=route.test.d.ts.map

package/dist/app/api/analysis/metrics/route.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.test.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/analysis/metrics/route.test.ts"],"names":[],"mappings":""}

package/dist/app/api/analysis/metrics/route.test.js

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { POST } from "../../../../handlers/metrics";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
+const minimalNode = (id, kind = "function") => ({
+    id,
+    kind,
+    name: id,
+    summary: "A node.",
+    contract: emptyContract(),
+    sourceRefs: [],
+    generatedRefs: [],
+    traceRefs: [],
+});
+const baseGraph = {
+    projectName: "Metrics Route Test",
+    mode: "essential",
+    generatedAt: "2026-03-14T00:00:00.000Z",
+    warnings: [],
+    workflows: [],
+    nodes: [],
+    edges: [],
+};
+describe("POST /api/analysis/metrics", () => {
+    it("returns zero metrics for an empty graph", async () => {
+        const response = await POST(new Request("http://localhost/api/analysis/metrics", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(baseGraph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.metrics.nodeCount).toBe(0);
+        expect(body.metrics.edgeCount).toBe(0);
+        expect(body.metrics.density).toBe(0);
+        expect(body.metrics.connectedComponents).toBe(0);
+        expect(body.metrics.analyzedAt).toBeTruthy();
+    });
+    it("computes correct metrics for a graph with mixed node kinds and edges", async () => {
+        const graph = {
+            ...baseGraph,
+            nodes: [
+                minimalNode("module:a", "module"),
+                minimalNode("api:b", "api"),
+                minimalNode("function:c", "function"),
+                minimalNode("function:d", "function"),
+            ],
+            edges: [
+                { from: "module:a", to: "api:b", kind: "calls", required: true, confidence: 1 },
+                { from: "api:b", to: "function:c", kind: "calls", required: true, confidence: 1 },
+                { from: "api:b", to: "function:d", kind: "calls", required: true, confidence: 1 },
+            ],
+        };
+        const response = await POST(new Request("http://localhost/api/analysis/metrics", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(graph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.metrics.nodeCount).toBe(4);
+        expect(body.metrics.edgeCount).toBe(3);
+        expect(body.metrics.density).toBeGreaterThan(0);
+        expect(body.metrics.nodesByKind["module"]).toBe(1);
+        expect(body.metrics.nodesByKind["api"]).toBe(1);
+        expect(body.metrics.nodesByKind["function"]).toBe(2);
+        expect(body.metrics.edgesByKind["calls"]).toBe(3);
+        expect(body.metrics.connectedComponents).toBe(1);
+        expect(body.metrics.isolatedNodes).toBe(0);
+        // module:a has out=1, api:b has out=2 in=1, function:c has in=1, function:d has in=1
+        expect(body.metrics.leafNodes).toBe(3);
+    });
+    it("returns 400 for an invalid request body", async () => {
+        const response = await POST(new Request("http://localhost/api/analysis/metrics", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(42),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(400);
+        expect(body.error).toBeTruthy();
+    });
+});

package/dist/app/api/analysis/smells/route.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=route.test.d.ts.map

package/dist/app/api/analysis/smells/route.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.test.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/analysis/smells/route.test.ts"],"names":[],"mappings":""}

package/dist/app/api/analysis/smells/route.test.js

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "vitest";
+import { POST } from "../../../../handlers/smells";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
+const baseGraph = {
+    projectName: "Smells Route Test",
+    mode: "essential",
+    generatedAt: "2026-03-14T00:00:00.000Z",
+    warnings: [],
+    workflows: [],
+    nodes: [],
+    edges: [],
+};
+const makeMethod = (name) => ({
+    name,
+    summary: `Does ${name}.`,
+    inputs: [],
+    outputs: [],
+    sideEffects: [],
+    calls: [],
+});
+describe("POST /api/analysis/smells", () => {
+    it("returns a clean smell report with health score near 100 for an empty graph", async () => {
+        const response = await POST(new Request("http://localhost/api/analysis/smells", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(baseGraph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.report.totalSmells).toBeGreaterThanOrEqual(0);
+        expect(body.report.analyzedAt).toBeTruthy();
+    });
+    it("detects a god-node with too many methods and responsibilities", async () => {
+        const graph = {
+            ...baseGraph,
+            nodes: [
+                {
+                    id: "module:god",
+                    kind: "module",
+                    name: "GodModule",
+                    summary: "Does everything.",
+                    contract: {
+                        ...emptyContract(),
+                        methods: Array.from({ length: 8 }, (_, i) => makeMethod(`method${i}`)),
+                        responsibilities: ["r1", "r2", "r3", "r4", "r5", "r6"],
+                    },
+                    sourceRefs: [],
+                    generatedRefs: [],
+                    traceRefs: [],
+                },
+            ],
+        };
+        const response = await POST(new Request("http://localhost/api/analysis/smells", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(graph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.report.totalSmells).toBeGreaterThan(0);
+        expect(body.report.healthScore).toBeLessThan(100);
+        const godNodeSmell = body.report.smells.find((s) => s.code === "god-node");
+        expect(godNodeSmell).toBeDefined();
+        expect(godNodeSmell?.severity).toBe("critical");
+        expect(godNodeSmell?.nodeId).toBe("module:god");
+    });
+    it("detects orphan nodes with no edges", async () => {
+        const graph = {
+            ...baseGraph,
+            nodes: [
+                {
+                    id: "function:orphan",
+                    kind: "function",
+                    name: "orphanFn",
+                    summary: "Nobody calls this.",
+                    contract: emptyContract(),
+                    sourceRefs: [],
+                    generatedRefs: [],
+                    traceRefs: [],
+                },
+            ],
+        };
+        const response = await POST(new Request("http://localhost/api/analysis/smells", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(graph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.report.smells.some((s) => s.code === "orphan-node")).toBe(true);
+    });
+    it("returns 400 for an invalid request body", async () => {
+        const response = await POST(new Request("http://localhost/api/analysis/smells", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ not: "a graph" }),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(400);
+        expect(body.error).toBeTruthy();
+    });
+});

package/dist/app/api/conflicts/route.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=route.test.d.ts.map

package/dist/app/api/conflicts/route.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.test.d.ts","sourceRoot":"","sources":["../../../../src/app/api/conflicts/route.test.ts"],"names":[],"mappings":""}

package/dist/app/api/conflicts/route.test.js

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { POST } from "../../../handlers/conflicts";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
+const fixturePath = path.resolve(process.cwd(), "test-fixtures/sample-repo");
+describe("POST /api/conflicts", () => {
+    it("returns drift conflicts against the repo fixture", async () => {
+        const graph = {
+            projectName: "Conflict Route",
+            mode: "essential",
+            generatedAt: "2026-03-14T00:00:00.000Z",
+            warnings: [],
+            workflows: [],
+            edges: [],
+            nodes: [
+                {
+                    id: "function:normalize",
+                    kind: "function",
+                    name: "normalizeTask",
+                    path: "src/services/task-service.ts",
+                    summary: "Wrong summary.",
+                    signature: "normalizeTask(input: string): string",
+                    contract: { ...emptyContract(), summary: "Wrong summary." },
+                    sourceRefs: [
+                        { kind: "repo", path: "src/services/task-service.ts", symbol: "normalizeTask" },
+                    ],
+                    generatedRefs: [],
+                    traceRefs: [],
+                },
+            ],
+        };
+        const response = await POST(new Request("http://localhost/api/conflicts", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ graph, repoPath: fixturePath }),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.report.conflicts.some((conflict) => conflict.kind === "signature-mismatch")).toBe(true);
+    });
+    it("returns 400 when repoPath is missing", async () => {
+        const graph = {
+            projectName: "NoRepoPath",
+            mode: "essential",
+            generatedAt: "2026-03-14T00:00:00.000Z",
+            warnings: [],
+            workflows: [],
+            edges: [],
+            nodes: [],
+        };
+        const response = await POST(new Request("http://localhost/api/conflicts", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ graph }),
+        }));
+        expect(response.status).toBe(400);
+    });
+});

package/dist/app/api/refactor/detect/route.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=route.test.d.ts.map

package/dist/app/api/refactor/detect/route.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.test.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/refactor/detect/route.test.ts"],"names":[],"mappings":""}

package/dist/app/api/refactor/detect/route.test.js

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { POST } from "../../../../handlers/refactor-detect";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
+const graph = {
+    projectName: "Refactor Detect Route",
+    mode: "essential",
+    generatedAt: "2026-03-26T00:00:00.000Z",
+    warnings: [],
+    workflows: [],
+    nodes: [
+        {
+            id: "function:auth",
+            kind: "function",
+            name: "authenticate",
+            summary: "Authenticate a user.",
+            contract: {
+                ...emptyContract(),
+                calls: [{ target: "GET /users", kind: "calls", description: undefined }],
+            },
+            sourceRefs: [],
+            generatedRefs: [],
+            traceRefs: [],
+        },
+        {
+            id: "api:users",
+            kind: "api",
+            name: "GET /users",
+            summary: "Users API.",
+            contract: emptyContract(),
+            sourceRefs: [],
+            generatedRefs: [],
+            traceRefs: [],
+        },
+    ],
+    edges: [],
+};
+describe("POST /api/refactor/detect", () => {
+    it("returns graph-scoped drift metadata", async () => {
+        const response = await POST(new Request("http://localhost/api/refactor/detect", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(graph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.report.totalIssues).toBeGreaterThan(0);
+        expect(body.report.provenance).toBe("deterministic");
+        expect(body.report.maturity).toBe("preview");
+        expect(body.report.scope).toBe("graph");
+    });
+    it("returns 400 for an invalid request body", async () => {
+        const response = await POST(new Request("http://localhost/api/refactor/detect", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ invalid: true }),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(400);
+        expect(body.error).toBeTruthy();
+    });
+});

package/dist/app/api/refactor/heal/route.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=route.test.d.ts.map

package/dist/app/api/refactor/heal/route.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.test.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/refactor/heal/route.test.ts"],"names":[],"mappings":""}

package/dist/app/api/refactor/heal/route.test.js

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { POST } from "../../../../handlers/refactor-heal";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
+const graph = {
+    projectName: "Refactor Heal Route",
+    mode: "essential",
+    generatedAt: "2026-03-26T00:00:00.000Z",
+    warnings: [],
+    workflows: [],
+    nodes: [
+        {
+            id: "function:auth",
+            kind: "function",
+            name: "authenticate",
+            summary: "Authenticate a user.",
+            contract: {
+                ...emptyContract(),
+                calls: [{ target: "GET /users", kind: "calls", description: undefined }],
+            },
+            sourceRefs: [],
+            generatedRefs: [],
+            traceRefs: [],
+        },
+        {
+            id: "api:users",
+            kind: "api",
+            name: "GET /users",
+            summary: "Users API.",
+            contract: emptyContract(),
+            sourceRefs: [],
+            generatedRefs: [],
+            traceRefs: [],
+        },
+    ],
+    edges: [],
+};
+describe("POST /api/refactor/heal", () => {
+    it("heals graph drift and returns truthfulness metadata", async () => {
+        const response = await POST(new Request("http://localhost/api/refactor/heal", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(graph),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(200);
+        expect(body.result.issuesFixed).toBeGreaterThan(0);
+        expect(body.result.provenance).toBe("deterministic");
+        expect(body.result.maturity).toBe("preview");
+        expect(body.result.scope).toBe("graph");
+        expect(body.result.graph.edges.some((edge) => edge.from === "function:auth" && edge.to === "api:users")).toBe(true);
+    });
+    it("returns 400 for an invalid request body", async () => {
+        const response = await POST(new Request("http://localhost/api/refactor/heal", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ invalid: true }),
+        }));
+        const body = await response.json();
+        expect(response.status).toBe(400);
+        expect(body.error).toBeTruthy();
+    });
+});

package/dist/bin/cli.js

@@ -1,43 +1,7 @@
-#!/usr/bin/env node
-/**
- * CLI entry-point shim for @abhinav2203/codeflow-analysis.
- *
- * This file is the executable referenced in the `bin` field of package.json.
- * It delegates to the TypeScript source via tsx so no build step is required
- * during development. After running `npm run build`, you can replace the
- * tsx invocation below with a direct `node` call to dist/invoke.js.
- */
+// Auto-generated bin entry — delegates to the invoke CLI
+import { runCLI } from "../invoke.js";
 
-import { execFileSync } from "node:child_process";
-import { accessSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const packageDir = path.resolve(__dirname, "..");
-
-// Determine the entrypoint: compiled JS if built, otherwise TypeScript source.
-let entrypoint;
-try {
-  entrypoint = path.resolve(packageDir, "dist/invoke.js");
-  accessSync(entrypoint);
-} catch {
-  entrypoint = path.resolve(packageDir, "src/invoke.ts");
-}
-
-// Prefer locally installed tsx in the monorepo.
-const tsxBin = path.resolve(packageDir, "node_modules/.bin/tsx");
-
-const useNode = process.env.CLI_FORCE_NODE === "true";
-const execPath = useNode ? process.execPath : tsxBin;
-const execArgs = useNode ? [entrypoint, ...process.argv.slice(2)] : [entrypoint, ...process.argv.slice(2)];
-
-try {
-  execFileSync(execPath, execArgs, { stdio: "inherit" });
-} catch (error) {
-  if (error.status != null) {
-    process.exit(error.status);
-  }
-  console.error(error);
+runCLI().catch((e) => {
+  console.error(e);
   process.exit(1);
-}
+});

package/dist/conflicts.d.ts

@@ -0,0 +1,12 @@
+import type { BlueprintGraph, ConflictReport } from "@abhinav2203/codeflow-core/schema";
+/**
+ * Detect structural conflicts between a blueprint graph and a live TypeScript repository.
+ *
+ * Conflicts detected:
+ * - `missing-in-repo`     – blueprint node has no corresponding symbol in the repo snapshot.
+ * - `missing-in-blueprint` – repo has a symbol not represented in the blueprint.
+ * - `signature-mismatch`  – blueprint node `signature` differs from the repo-derived signature.
+ * - `summary-mismatch`   – blueprint node `summary` differs from the repo-derived summary.
+ */
+export declare const detectGraphConflicts: (graph: BlueprintGraph, repoPath: string) => Promise<ConflictReport>;
+//# sourceMappingURL=conflicts.d.ts.map

package/dist/conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflicts.d.ts","sourceRoot":"","sources":["../src/conflicts.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,cAAc,EAGd,cAAc,EACf,MAAM,mCAAmC,CAAC;AAK3C;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,EACrB,UAAU,MAAM,KACf,OAAO,CAAC,cAAc,CAgFxB,CAAC"}

package/dist/conflicts.js

@@ -0,0 +1,77 @@
+import path from "node:path";
+import { analyzeTypeScriptRepo } from "@abhinav2203/codeflow-core/analyzer";
+const repoKeyForNode = (node) => `${node.kind}:${node.path ?? ""}:${node.name}`;
+/**
+ * Detect structural conflicts between a blueprint graph and a live TypeScript repository.
+ *
+ * Conflicts detected:
+ * - `missing-in-repo`     – blueprint node has no corresponding symbol in the repo snapshot.
+ * - `missing-in-blueprint` – repo has a symbol not represented in the blueprint.
+ * - `signature-mismatch`  – blueprint node `signature` differs from the repo-derived signature.
+ * - `summary-mismatch`   – blueprint node `summary` differs from the repo-derived summary.
+ */
+export const detectGraphConflicts = async (graph, repoPath) => {
+    const repoGraph = await analyzeTypeScriptRepo(path.resolve(repoPath));
+    const conflicts = [];
+    // Only consider code-bearing nodes (not modules, which are structural containers).
+    const repoNodes = repoGraph.nodes.filter((node) => node.kind !== "module");
+    const blueprintRepoNodes = graph.nodes.filter((node) => node.sourceRefs.some((ref) => ref.kind === "repo"));
+    const repoMap = new Map(repoNodes.map((node) => [repoKeyForNode(node), node]));
+    const blueprintMap = new Map(blueprintRepoNodes.map((node) => [repoKeyForNode(node), node]));
+    // Check each blueprint node against the repo snapshot.
+    for (const blueprintNode of blueprintRepoNodes) {
+        const repoNode = repoMap.get(repoKeyForNode(blueprintNode));
+        if (!repoNode) {
+            conflicts.push({
+                kind: "missing-in-repo",
+                nodeId: blueprintNode.id,
+                path: blueprintNode.path,
+                blueprintValue: blueprintNode.name,
+                message: `${blueprintNode.name} is in the blueprint but not in the repo snapshot.`,
+                suggestedAction: "Remove the node from the blueprint or recreate it in the repo.",
+            });
+            continue;
+        }
+        if ((blueprintNode.signature ?? "") !== (repoNode.signature ?? "")) {
+            conflicts.push({
+                kind: "signature-mismatch",
+                nodeId: blueprintNode.id,
+                path: blueprintNode.path,
+                blueprintValue: blueprintNode.signature,
+                repoValue: repoNode.signature,
+                message: `${blueprintNode.name} has a different signature in the repo.`,
+                suggestedAction: "Refresh the blueprint contract from the repo or update the implementation.",
+            });
+        }
+        if (blueprintNode.summary &&
+            repoNode.summary &&
+            blueprintNode.summary !== repoNode.summary) {
+            conflicts.push({
+                kind: "summary-mismatch",
+                nodeId: blueprintNode.id,
+                path: blueprintNode.path,
+                blueprintValue: blueprintNode.summary,
+                repoValue: repoNode.summary,
+                message: `${blueprintNode.name} summary diverges from the repo-derived description.`,
+                suggestedAction: "Review the contract summary and align it with current behavior.",
+            });
+        }
+    }
+    // Detect repo symbols missing from the blueprint.
+    for (const repoNode of repoNodes) {
+        if (!blueprintMap.has(repoKeyForNode(repoNode))) {
+            conflicts.push({
+                kind: "missing-in-blueprint",
+                path: repoNode.path,
+                repoValue: repoNode.name,
+                message: `${repoNode.name} exists in the repo but is not represented in the blueprint.`,
+                suggestedAction: "Add the node to the blueprint or mark it intentionally out of scope.",
+            });
+        }
+    }
+    return {
+        checkedAt: new Date().toISOString(),
+        repoPath: path.resolve(repoPath),
+        conflicts,
+    };
+};

package/dist/conflicts.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=conflicts.test.d.ts.map

package/dist/conflicts.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflicts.test.d.ts","sourceRoot":"","sources":["../src/conflicts.test.ts"],"names":[],"mappings":""}