@abhinav2203/codeflow-analysis 0.1.0 → 0.1.1

package/dist/conflicts.test.js

@@ -0,0 +1,98 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { detectGraphConflicts } from "./conflicts";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
+const fixturePath = path.resolve(process.cwd(), "test-fixtures/sample-repo");
+const node = (id, overrides = {}) => ({
+    id,
+    kind: overrides.kind ?? "function",
+    name: overrides.name ?? id,
+    path: overrides.path,
+    summary: overrides.summary ?? id,
+    signature: overrides.signature,
+    contract: { ...emptyContract(), summary: overrides.summary ?? id },
+    sourceRefs: overrides.sourceRefsPath
+        ? [{ kind: "repo", path: overrides.sourceRefsPath, symbol: overrides.name ?? id }]
+        : [],
+    generatedRefs: [],
+    traceRefs: [],
+});
+describe("detectGraphConflicts", () => {
+    it("finds a signature-mismatch when blueprint signature diverges from repo", async () => {
+        const graph = {
+            projectName: "Conflicts",
+            mode: "essential",
+            generatedAt: "2026-03-14T00:00:00.000Z",
+            warnings: [],
+            workflows: [],
+            edges: [],
+            nodes: [
+                node("function:normalize", {
+                    kind: "function",
+                    path: "src/services/task-service.ts",
+                    name: "normalizeTask",
+                    summary: "Wrong summary.",
+                    signature: "normalizeTask(input: string): string",
+                    sourceRefsPath: "src/services/task-service.ts",
+                }),
+            ],
+        };
+        const report = await detectGraphConflicts(graph, fixturePath);
+        expect(report.conflicts.some((c) => c.kind === "signature-mismatch")).toBe(true);
+    });
+    it("finds missing-in-blueprint when repo has a symbol not in the blueprint", async () => {
+        const graph = {
+            projectName: "MissingInBlueprint",
+            mode: "essential",
+            generatedAt: "2026-03-14T00:00:00.000Z",
+            warnings: [],
+            workflows: [],
+            edges: [],
+            nodes: [], // empty — all repo symbols should be reported missing
+        };
+        const report = await detectGraphConflicts(graph, fixturePath);
+        expect(report.conflicts.some((c) => c.kind === "missing-in-blueprint")).toBe(true);
+    });
+    it("returns empty conflicts for an empty graph and empty repo", async () => {
+        // Using a path that exists but has no matching symbols
+        const report = await detectGraphConflicts({
+            projectName: "Empty",
+            mode: "essential",
+            generatedAt: "2026-03-14T00:00:00.000Z",
+            warnings: [],
+            workflows: [],
+            edges: [],
+            nodes: [],
+        }, fixturePath);
+        // sample-repo has symbols, so missing-in-blueprint will fire
+        // but there should be no signature-mismatch
+        expect(report.conflicts.every((c) => c.kind === "missing-in-blueprint")).toBe(true);
+    });
+    it("returns a valid checkedAt timestamp", async () => {
+        const report = await detectGraphConflicts({
+            projectName: "Timestamp",
+            mode: "essential",
+            generatedAt: "2026-03-14T00:00:00.000Z",
+            warnings: [],
+            workflows: [],
+            edges: [],
+            nodes: [],
+        }, fixturePath);
+        expect(() => new Date(report.checkedAt)).not.toThrow();
+        expect(report.repoPath).toBe(path.resolve(fixturePath));
+    });
+    it("includes suggestedAction on every conflict", async () => {
+        const report = await detectGraphConflicts({
+            projectName: "Suggestions",
+            mode: "essential",
+            generatedAt: "2026-03-14T00:00:00.000Z",
+            warnings: [],
+            workflows: [],
+            edges: [],
+            nodes: [],
+        }, fixturePath);
+        for (const conflict of report.conflicts) {
+            expect(conflict.suggestedAction.length).toBeGreaterThan(0);
+        }
+    });
+});

package/dist/cycles.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import type { BlueprintGraph } from "@abhinav2203/codeflow-core/schema";
+export declare const cycleSchema: z.ZodObject<{
+    nodeIds: z.ZodArray<z.ZodString>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        kind: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Cycle = z.infer<typeof cycleSchema>;
+export declare const cycleReportSchema: z.ZodObject<{
+    analyzedAt: z.ZodString;
+    totalCycles: z.ZodNumber;
+    maxCycleLength: z.ZodNumber;
+    cycles: z.ZodArray<z.ZodObject<{
+        nodeIds: z.ZodArray<z.ZodString>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            kind: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    affectedNodeIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CycleReport = z.infer<typeof cycleReportSchema>;
+/**
+ * Detect all directed cycles in a blueprint graph using Tarjan's strongly-connected
+ * components algorithm (iterative, stack-safe).
+ *
+ * Self-loop edges (from === to) are detected separately and treated as single-node cycles.
+ */
+export declare const detectCycles: (graph: BlueprintGraph) => CycleReport;
+/**
+ * Returns true if the graph contains at least one directed cycle.
+ * Faster than detectCycles — stops early on the first cycle found.
+ */
+export declare const hasCycles: (graph: BlueprintGraph) => boolean;
+//# sourceMappingURL=cycles.d.ts.map

package/dist/cycles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycles.d.ts","sourceRoot":"","sources":["../src/cycles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAExE,eAAO,MAAM,WAAW;;;;;;;iBAStB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBAM5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAmE5D;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,cAAc,KAAG,WA2CpD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,cAAc,KAAG,OAejD,CAAC"}

package/dist/cycles.js

@@ -0,0 +1,129 @@
+import { z } from "zod";
+export const cycleSchema = z.object({
+    nodeIds: z.array(z.string()),
+    edges: z.array(z.object({
+        from: z.string(),
+        to: z.string(),
+        kind: z.string(),
+    })),
+});
+export const cycleReportSchema = z.object({
+    analyzedAt: z.string(),
+    totalCycles: z.number(),
+    maxCycleLength: z.number(),
+    cycles: z.array(cycleSchema),
+    affectedNodeIds: z.array(z.string()),
+});
+const tarjanIterative = (nodeIds, adjacency) => {
+    const indices = new Map();
+    const lowlinks = new Map();
+    const onStack = new Set();
+    const stack = [];
+    const sccs = [];
+    let index = 0;
+    for (const root of nodeIds) {
+        if (indices.has(root))
+            continue;
+        const callStack = [{ node: root, neighborIndex: 0, neighbors: adjacency.get(root) ?? [] }];
+        indices.set(root, index);
+        lowlinks.set(root, index);
+        index++;
+        stack.push(root);
+        onStack.add(root);
+        while (callStack.length > 0) {
+            const frame = callStack[callStack.length - 1];
+            if (frame.neighborIndex < frame.neighbors.length) {
+                const neighbor = frame.neighbors[frame.neighborIndex];
+                frame.neighborIndex++;
+                if (!indices.has(neighbor)) {
+                    indices.set(neighbor, index);
+                    lowlinks.set(neighbor, index);
+                    index++;
+                    stack.push(neighbor);
+                    onStack.add(neighbor);
+                    callStack.push({ node: neighbor, neighborIndex: 0, neighbors: adjacency.get(neighbor) ?? [] });
+                }
+                else if (onStack.has(neighbor)) {
+                    lowlinks.set(frame.node, Math.min(lowlinks.get(frame.node), lowlinks.get(neighbor)));
+                }
+            }
+            else {
+                if (lowlinks.get(frame.node) === indices.get(frame.node)) {
+                    const scc = [];
+                    let w;
+                    do {
+                        w = stack.pop();
+                        onStack.delete(w);
+                        scc.push(w);
+                    } while (w !== frame.node);
+                    sccs.push(scc);
+                }
+                callStack.pop();
+                if (callStack.length > 0) {
+                    const parent = callStack[callStack.length - 1];
+                    lowlinks.set(parent.node, Math.min(lowlinks.get(parent.node), lowlinks.get(frame.node)));
+                }
+            }
+        }
+    }
+    return sccs;
+};
+/**
+ * Detect all directed cycles in a blueprint graph using Tarjan's strongly-connected
+ * components algorithm (iterative, stack-safe).
+ *
+ * Self-loop edges (from === to) are detected separately and treated as single-node cycles.
+ */
+export const detectCycles = (graph) => {
+    const nodeIds = graph.nodes.map((n) => n.id);
+    const adjacency = new Map();
+    for (const id of nodeIds) {
+        adjacency.set(id, []);
+    }
+    for (const edge of graph.edges) {
+        adjacency.get(edge.from)?.push(edge.to);
+    }
+    const sccs = tarjanIterative(nodeIds, adjacency);
+    // A self-loop (from === to) is a genuine cycle but Tarjan's SCC returns it as
+    // a size-1 SCC. Detect them separately and treat them as single-node cycles.
+    const selfLoopNodeIds = new Set(graph.edges.filter((e) => e.from === e.to).map((e) => e.from));
+    const selfLoopSccs = [...selfLoopNodeIds].map((id) => [id]);
+    const sccSet = [
+        ...sccs.filter((scc) => scc.length >= 2),
+        ...selfLoopSccs
+    ];
+    const cycles = sccSet.map((scc) => {
+        const memberSet = new Set(scc);
+        const edges = graph.edges
+            .filter((e) => memberSet.has(e.from) && memberSet.has(e.to))
+            .map((e) => ({ from: e.from, to: e.to, kind: e.kind }));
+        return { nodeIds: scc, edges };
+    });
+    const affectedNodeIds = [...new Set(cycles.flatMap((c) => c.nodeIds))];
+    const maxCycleLength = cycles.reduce((max, c) => Math.max(max, c.nodeIds.length), 0);
+    return {
+        analyzedAt: new Date().toISOString(),
+        totalCycles: cycles.length,
+        maxCycleLength,
+        cycles,
+        affectedNodeIds,
+    };
+};
+/**
+ * Returns true if the graph contains at least one directed cycle.
+ * Faster than detectCycles — stops early on the first cycle found.
+ */
+export const hasCycles = (graph) => {
+    if (graph.edges.some((e) => e.from === e.to))
+        return true;
+    const nodeIds = graph.nodes.map((n) => n.id);
+    const adjacency = new Map();
+    for (const id of nodeIds) {
+        adjacency.set(id, []);
+    }
+    for (const edge of graph.edges) {
+        adjacency.get(edge.from)?.push(edge.to);
+    }
+    const sccs = tarjanIterative(nodeIds, adjacency);
+    return sccs.some((scc) => scc.length >= 2);
+};

package/dist/cycles.test.d.ts

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

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

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

package/dist/cycles.test.js

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { detectCycles, hasCycles } from "./cycles";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
+const node = (id) => ({
+    id,
+    kind: "module",
+    name: id,
+    summary: id,
+    contract: emptyContract(),
+    sourceRefs: [],
+    generatedRefs: [],
+    traceRefs: [],
+});
+const edge = (from, to) => ({
+    from,
+    to,
+    kind: "calls",
+    required: true,
+    confidence: 1,
+});
+const graph = (projectName, nodes, edges) => ({
+    projectName,
+    mode: "essential",
+    generatedAt: "2026-03-14T00:00:00.000Z",
+    warnings: [],
+    workflows: [],
+    nodes,
+    edges,
+});
+describe("detectCycles", () => {
+    it("returns no cycles for a DAG", () => {
+        const report = detectCycles(graph("DAG", [node("A"), node("B"), node("C")], [edge("A", "B"), edge("B", "C")]));
+        expect(report.totalCycles).toBe(0);
+        expect(report.affectedNodeIds).toHaveLength(0);
+    });
+    it("detects a simple two-node cycle", () => {
+        const report = detectCycles(graph("TwoNodeCycle", [node("A"), node("B")], [edge("A", "B"), edge("B", "A")]));
+        expect(report.totalCycles).toBe(1);
+        expect(report.affectedNodeIds).toContain("A");
+        expect(report.affectedNodeIds).toContain("B");
+    });
+    it("detects multiple independent cycles", () => {
+        const report = detectCycles(graph("MultiCycle", [node("A"), node("B"), node("C"), node("D")], [edge("A", "B"), edge("B", "A"), edge("C", "D"), edge("D", "C")]));
+        expect(report.totalCycles).toBe(2);
+    });
+    it("handles empty graph", () => {
+        const report = detectCycles(graph("Empty", [], []));
+        expect(report.totalCycles).toBe(0);
+    });
+    it("detects a self-loop edge as a cycle", () => {
+        const report = detectCycles(graph("SelfLoop", [node("A")], [{ from: "A", to: "A", kind: "calls", required: true, confidence: 1 }]));
+        expect(report.totalCycles).toBe(1);
+        expect(report.affectedNodeIds).toContain("A");
+    });
+    it("returns maxCycleLength correctly", () => {
+        const report = detectCycles(graph("ThreeCycle", [node("A"), node("B"), node("C")], [edge("A", "B"), edge("B", "C"), edge("C", "A")]));
+        expect(report.totalCycles).toBe(1);
+        expect(report.maxCycleLength).toBe(3);
+    });
+    it("cycles array contains edges belonging to the SCC", () => {
+        const report = detectCycles(graph("EdgeCycle", [node("X"), node("Y")], [edge("X", "Y"), edge("Y", "X")]));
+        const cycle = report.cycles[0];
+        expect(cycle.nodeIds).toContain("X");
+        expect(cycle.nodeIds).toContain("Y");
+        expect(cycle.edges).toHaveLength(2);
+        expect(cycle.edges.map((e) => `${e.from}→${e.to}`)).toEqual(expect.arrayContaining(["X→Y", "Y→X"]));
+    });
+});
+describe("hasCycles", () => {
+    it("returns false for a DAG", () => {
+        expect(hasCycles(graph("DAG", [node("A"), node("B")], [edge("A", "B")]))).toBe(false);
+    });
+    it("returns true when a two-node cycle exists", () => {
+        expect(hasCycles(graph("Cyclic", [node("A"), node("B")], [edge("A", "B"), edge("B", "A")]))).toBe(true);
+    });
+    it("returns true for a self-loop", () => {
+        expect(hasCycles(graph("SelfLoop", [node("A")], [{ from: "A", to: "A", kind: "calls", required: true, confidence: 1 }]))).toBe(true);
+    });
+    it("returns false for empty graph", () => {
+        expect(hasCycles(graph("Empty", [], []))).toBe(false);
+    });
+});

package/dist/handlers/conflicts.d.ts

@@ -0,0 +1,28 @@
+import { NextResponse } from "next/server";
+/**
+ * POST /api/conflicts
+ *
+ * Body: { graph: BlueprintGraph, repoPath: string }
+ *
+ * Compares a blueprint graph against a live TypeScript repository,
+ * detecting signature mismatches, summary mismatches, missing-in-repo
+ * nodes, and missing-in-blueprint symbols.
+ */
+export declare function POST(request: Request): Promise<NextResponse<{
+    report: {
+        checkedAt: string;
+        repoPath: string;
+        conflicts: {
+            kind: "missing-in-repo" | "missing-in-blueprint" | "signature-mismatch" | "summary-mismatch";
+            message: string;
+            suggestedAction: string;
+            nodeId?: string | undefined;
+            path?: string | undefined;
+            blueprintValue?: string | undefined;
+            repoValue?: string | undefined;
+        }[];
+    };
+}> | NextResponse<{
+    error: string;
+}>>;
+//# sourceMappingURL=conflicts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conflicts.d.ts","sourceRoot":"","sources":["../../src/handlers/conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C;;;;;;;;GAQG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;;;;IAc1C"}

package/dist/handlers/conflicts.js

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+import { detectGraphConflicts } from "../conflicts";
+import { conflictCheckRequestSchema } from "@abhinav2203/codeflow-core/schema";
+/**
+ * POST /api/conflicts
+ *
+ * Body: { graph: BlueprintGraph, repoPath: string }
+ *
+ * Compares a blueprint graph against a live TypeScript repository,
+ * detecting signature mismatches, summary mismatches, missing-in-repo
+ * nodes, and missing-in-blueprint symbols.
+ */
+export async function POST(request) {
+    try {
+        const payload = conflictCheckRequestSchema.parse(await request.json());
+        const report = await detectGraphConflicts(payload.graph, payload.repoPath);
+        return NextResponse.json({ report });
+    }
+    catch (error) {
+        return NextResponse.json({
+            error: error instanceof Error ? error.message : "Failed to analyze graph conflicts.",
+        }, { status: 400 });
+    }
+}

package/dist/handlers/cycles.d.ts

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+/**
+ * POST /api/analysis/cycles
+ *
+ * Body: {@link BlueprintGraph}
+ *
+ * Returns a cycle detection report for the submitted blueprint graph.
+ * Includes total cycle count, affected node IDs, per-cycle edge details,
+ * and a convenience `hasCycles` boolean.
+ */
+export declare function POST(request: Request): Promise<NextResponse<{
+    report: {
+        hasCycles: boolean;
+        analyzedAt: string;
+        totalCycles: number;
+        maxCycleLength: number;
+        cycles: {
+            nodeIds: string[];
+            edges: {
+                from: string;
+                to: string;
+                kind: string;
+            }[];
+        }[];
+        affectedNodeIds: string[];
+    };
+}> | NextResponse<{
+    error: string;
+}>>;
+//# sourceMappingURL=cycles.d.ts.map

package/dist/handlers/cycles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycles.d.ts","sourceRoot":"","sources":["../../src/handlers/cycles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C;;;;;;;;GAQG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;;;;;;IAc1C"}

package/dist/handlers/cycles.js

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+import { detectCycles, hasCycles } from "../cycles";
+import { blueprintGraphSchema } from "@abhinav2203/codeflow-core/schema";
+/**
+ * POST /api/analysis/cycles
+ *
+ * Body: {@link BlueprintGraph}
+ *
+ * Returns a cycle detection report for the submitted blueprint graph.
+ * Includes total cycle count, affected node IDs, per-cycle edge details,
+ * and a convenience `hasCycles` boolean.
+ */
+export async function POST(request) {
+    try {
+        const payload = blueprintGraphSchema.parse(await request.json());
+        const report = detectCycles(payload);
+        return NextResponse.json({ report: { ...report, hasCycles: hasCycles(payload) } });
+    }
+    catch (error) {
+        return NextResponse.json({
+            error: error instanceof Error ? error.message : "Failed to detect dependency cycles.",
+        }, { status: 400 });
+    }
+}

package/dist/handlers/metrics.d.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from "next/server";
+/**
+ * POST /api/analysis/metrics
+ *
+ * Body: {@link BlueprintGraph}
+ *
+ * Returns structural graph metrics: node/edge counts, degree statistics,
+ * density, connected components, and contract-level averages.
+ */
+export declare function POST(request: Request): Promise<NextResponse<{
+    metrics: {
+        analyzedAt: string;
+        nodeCount: number;
+        edgeCount: number;
+        nodesByKind: Record<string, number>;
+        edgesByKind: Record<string, number>;
+        nodesByStatus: Record<string, number>;
+        density: number;
+        avgDegree: number;
+        maxInDegree: number;
+        maxOutDegree: number;
+        avgMethodsPerNode: number;
+        avgResponsibilitiesPerNode: number;
+        totalMethods: number;
+        totalResponsibilities: number;
+        connectedComponents: number;
+        isolatedNodes: number;
+        leafNodes: number;
+        maxInDegreeNodeId?: string | undefined;
+        maxOutDegreeNodeId?: string | undefined;
+    };
+}> | NextResponse<{
+    error: string;
+}>>;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/handlers/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../src/handlers/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C;;;;;;;GAOG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;IAc1C"}

package/dist/handlers/metrics.js

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { computeGraphMetrics } from "../metrics";
+import { blueprintGraphSchema } from "@abhinav2203/codeflow-core/schema";
+/**
+ * POST /api/analysis/metrics
+ *
+ * Body: {@link BlueprintGraph}
+ *
+ * Returns structural graph metrics: node/edge counts, degree statistics,
+ * density, connected components, and contract-level averages.
+ */
+export async function POST(request) {
+    try {
+        const payload = blueprintGraphSchema.parse(await request.json());
+        const metrics = computeGraphMetrics(payload);
+        return NextResponse.json({ metrics });
+    }
+    catch (error) {
+        return NextResponse.json({
+            error: error instanceof Error ? error.message : "Failed to compute graph metrics.",
+        }, { status: 400 });
+    }
+}

package/dist/handlers/refactor-detect.d.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from "next/server";
+/**
+ * POST /api/refactor/detect
+ *
+ * Body: {@link BlueprintGraph}
+ *
+ * Returns a {@link RefactorReport} describing all detected drift issues:
+ * broken edges, missing edges, and signature drift.
+ */
+export declare function POST(request: Request): Promise<NextResponse<{
+    report: import("..").RefactorReport;
+}> | NextResponse<{
+    error: string;
+}>>;
+//# sourceMappingURL=refactor-detect.d.ts.map

package/dist/handlers/refactor-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refactor-detect.d.ts","sourceRoot":"","sources":["../../src/handlers/refactor-detect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C;;;;;;;GAOG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO;;;;IAc1C"}

package/dist/handlers/refactor-detect.js

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { detectDrift } from "../refactor";
+import { blueprintGraphSchema } from "@abhinav2203/codeflow-core/schema";
+/**
+ * POST /api/refactor/detect
+ *
+ * Body: {@link BlueprintGraph}
+ *
+ * Returns a {@link RefactorReport} describing all detected drift issues:
+ * broken edges, missing edges, and signature drift.
+ */
+export async function POST(request) {
+    try {
+        const graph = blueprintGraphSchema.parse(await request.json());
+        const report = detectDrift(graph);
+        return NextResponse.json({ report });
+    }
+    catch (error) {
+        return NextResponse.json({
+            error: error instanceof Error ? error.message : "Failed to detect architectural drift.",
+        }, { status: 400 });
+    }
+}

package/dist/handlers/refactor-heal.d.ts

@@ -0,0 +1,19 @@
+import { NextResponse } from "next/server";
+/**
+ * POST /api/refactor/heal
+ *
+ * Body: {@link BlueprintGraph}
+ *
+ * Detects all drift issues, then auto-heals the graph:
+ * removes broken edges, synthesises missing edges from contract calls,
+ * and syncs node signatures to match their first contract method.
+ *
+ * Returns both the detection report and the healed graph.
+ */
+export declare function POST(request: Request): Promise<NextResponse<{
+    report: import("..").RefactorReport;
+    result: import("..").HealResult;
+}> | NextResponse<{
+    error: string;
+}>>;
+//# sourceMappingURL=refactor-heal.d.ts.map

package/dist/handlers/refactor-heal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refactor-heal.d.ts","sourceRoot":"","sources":["../../src/handlers/refactor-heal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAK3C;;;;;;;;;;GAUG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO;;;;;IAe1C"}

package/dist/handlers/refactor-heal.js

@@ -0,0 +1,27 @@
+import { NextResponse } from "next/server";
+import { detectDrift, healGraph } from "../refactor";
+import { blueprintGraphSchema } from "@abhinav2203/codeflow-core/schema";
+/**
+ * POST /api/refactor/heal
+ *
+ * Body: {@link BlueprintGraph}
+ *
+ * Detects all drift issues, then auto-heals the graph:
+ * removes broken edges, synthesises missing edges from contract calls,
+ * and syncs node signatures to match their first contract method.
+ *
+ * Returns both the detection report and the healed graph.
+ */
+export async function POST(request) {
+    try {
+        const graph = blueprintGraphSchema.parse(await request.json());
+        const report = detectDrift(graph);
+        const result = healGraph(graph, report);
+        return NextResponse.json({ report, result });
+    }
+    catch (error) {
+        return NextResponse.json({
+            error: error instanceof Error ? error.message : "Failed to heal architectural drift.",
+        }, { status: 400 });
+    }
+}

package/dist/handlers/smells.d.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from "next/server";
+/**
+ * POST /api/analysis/smells
+ *
+ * Body: {@link BlueprintGraph}
+ *
+ * Returns an architecture smell report including god-node, hub-node,
+ * orphan-node, tight-coupling, unstable-dependency, and scattered-responsibility
+ * detections along with an overall health score.
+ */
+export declare function POST(request: Request): Promise<NextResponse<{
+    report: {
+        analyzedAt: string;
+        totalSmells: number;
+        smells: {
+            code: string;
+            severity: "warning" | "info" | "critical";
+            message: string;
+            suggestion: string;
+            nodeId?: string | undefined;
+        }[];
+        healthScore: number;
+    };
+}> | NextResponse<{
+    error: string;
+}>>;
+//# sourceMappingURL=smells.d.ts.map