@abhinav2203/codeflow-analysis 0.1.0 → 0.1.2

package/dist/smells.js

@@ -0,0 +1,186 @@
+import { z } from "zod";
+export const smellSchema = z.object({
+    code: z.string(),
+    severity: z.enum(["info", "warning", "critical"]),
+    nodeId: z.string().optional(),
+    message: z.string(),
+    suggestion: z.string(),
+});
+export const smellReportSchema = z.object({
+    analyzedAt: z.string(),
+    totalSmells: z.number(),
+    smells: z.array(smellSchema),
+    healthScore: z.number(),
+});
+const GOD_NODE_MIN_METHODS = 7;
+const GOD_NODE_MIN_RESPONSIBILITIES = 5;
+const HUB_NODE_MIN_DEGREE = 8;
+const TIGHT_COUPLING_MIN_EDGES = 3;
+const UNSTABLE_DEP_MIN_INCOMING = 1;
+const UNSTABLE_DEP_MIN_OUTGOING = 4;
+const UNSTABLE_DEP_THRESHOLD = 0.8;
+const SCATTERED_MIN_SIDE_EFFECTS = 4;
+const CRITICAL_PENALTY = 15;
+const WARNING_PENALTY = 8;
+const INFO_PENALTY = 3;
+/** Nodes with too many methods AND responsibilities — violates single responsibility. */
+const detectGodNodes = (graph) => graph.nodes
+    .filter((n) => n.contract.methods.length >= GOD_NODE_MIN_METHODS &&
+    n.contract.responsibilities.length >= GOD_NODE_MIN_RESPONSIBILITIES)
+    .map((n) => ({
+    code: "god-node",
+    severity: "critical",
+    nodeId: n.id,
+    message: `Node "${n.name}" has ${n.contract.methods.length} methods and ${n.contract.responsibilities.length} responsibilities.`,
+    suggestion: "Split this node into smaller, focused modules with single responsibilities.",
+}));
+/** Nodes with very high total degree — potential hub that other nodes depend on too heavily. */
+const detectHubNodes = (graph) => {
+    const inDegree = new Map();
+    const outDegree = new Map();
+    for (const node of graph.nodes) {
+        inDegree.set(node.id, 0);
+        outDegree.set(node.id, 0);
+    }
+    for (const edge of graph.edges) {
+        inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+        outDegree.set(edge.from, (outDegree.get(edge.from) ?? 0) + 1);
+    }
+    return graph.nodes
+        .filter((n) => (inDegree.get(n.id) ?? 0) + (outDegree.get(n.id) ?? 0) >= HUB_NODE_MIN_DEGREE)
+        .map((n) => {
+        const total = (inDegree.get(n.id) ?? 0) + (outDegree.get(n.id) ?? 0);
+        return {
+            code: "hub-node",
+            severity: "warning",
+            nodeId: n.id,
+            message: `Node "${n.name}" has a total degree of ${total} (in: ${inDegree.get(n.id) ?? 0}, out: ${outDegree.get(n.id) ?? 0}).`,
+            suggestion: "Introduce an intermediary or facade to reduce direct dependencies on this node.",
+        };
+    });
+};
+/** Nodes with no incoming or outgoing edges — may be dead code or missing connections. */
+const detectOrphanNodes = (graph) => {
+    const connected = new Set();
+    for (const edge of graph.edges) {
+        connected.add(edge.from);
+        connected.add(edge.to);
+    }
+    return graph.nodes
+        .filter((n) => !connected.has(n.id))
+        .map((n) => ({
+        code: "orphan-node",
+        severity: "info",
+        nodeId: n.id,
+        message: `Node "${n.name}" has no incoming or outgoing edges.`,
+        suggestion: "Verify this node is still needed; it may be dead code or missing connections.",
+    }));
+};
+/** Node pairs connected by three or more distinct edges — excessive coupling. */
+const detectTightCoupling = (graph) => {
+    const pairCounts = new Map();
+    for (const edge of graph.edges) {
+        const [a, b] = [edge.from, edge.to].sort();
+        const key = `${a}\0${b}`;
+        const entry = pairCounts.get(key);
+        if (entry) {
+            entry.count++;
+        }
+        else {
+            pairCounts.set(key, { a, b, count: 1 });
+        }
+    }
+    const smells = [];
+    for (const { a, b, count } of pairCounts.values()) {
+        if (count >= TIGHT_COUPLING_MIN_EDGES) {
+            smells.push({
+                code: "tight-coupling",
+                severity: "warning",
+                nodeId: undefined,
+                message: `Nodes "${a}" and "${b}" are connected by ${count} edges.`,
+                suggestion: "Consider merging these nodes or extracting a shared interface to reduce coupling.",
+            });
+        }
+    }
+    return smells;
+};
+/**
+ * Nodes that are depended upon (incoming edges) but have many outgoing edges —
+ * unstable intermediates that are prone to breaking dependents when changed.
+ */
+const detectUnstableDependencies = (graph) => {
+    const inCount = new Map();
+    const outCount = new Map();
+    for (const node of graph.nodes) {
+        inCount.set(node.id, 0);
+        outCount.set(node.id, 0);
+    }
+    for (const edge of graph.edges) {
+        inCount.set(edge.to, (inCount.get(edge.to) ?? 0) + 1);
+        outCount.set(edge.from, (outCount.get(edge.from) ?? 0) + 1);
+    }
+    return graph.nodes
+        .filter((n) => {
+        const inc = inCount.get(n.id) ?? 0;
+        const out = outCount.get(n.id) ?? 0;
+        if (inc < UNSTABLE_DEP_MIN_INCOMING || out < UNSTABLE_DEP_MIN_OUTGOING)
+            return false;
+        return out / (inc + out) > UNSTABLE_DEP_THRESHOLD;
+    })
+        .map((n) => {
+        const inc = inCount.get(n.id) ?? 0;
+        const out = outCount.get(n.id) ?? 0;
+        const instability = out / (inc + out);
+        return {
+            code: "unstable-dependency",
+            severity: "warning",
+            nodeId: n.id,
+            message: `Node "${n.name}" has instability ${instability.toFixed(2)} (in: ${inc}, out: ${out}) and is depended upon.`,
+            suggestion: "Stabilize this node by reducing its outgoing dependencies or shielding dependents with an abstraction.",
+        };
+    });
+};
+/** Nodes that declare many side effects — scattered responsibilities across the system. */
+const detectScatteredResponsibility = (graph) => graph.nodes
+    .filter((n) => n.contract.sideEffects.length >= SCATTERED_MIN_SIDE_EFFECTS)
+    .map((n) => ({
+    code: "scattered-responsibility",
+    severity: "info",
+    nodeId: n.id,
+    message: `Node "${n.name}" declares ${n.contract.sideEffects.length} side effects.`,
+    suggestion: "Extract side effects into dedicated service nodes to improve testability and clarity.",
+}));
+const computeHealthScore = (smells) => {
+    let score = 100;
+    for (const smell of smells) {
+        if (smell.severity === "critical")
+            score -= CRITICAL_PENALTY;
+        else if (smell.severity === "warning")
+            score -= WARNING_PENALTY;
+        else
+            score -= INFO_PENALTY;
+    }
+    return Math.max(0, score);
+};
+/**
+ * Detect all architecture smells in a blueprint graph.
+ *
+ * Smell categories: god-node, hub-node, orphan-node, tight-coupling,
+ * unstable-dependency, scattered-responsibility.
+ */
+export const detectSmells = (graph) => {
+    const smells = [
+        ...detectGodNodes(graph),
+        ...detectHubNodes(graph),
+        ...detectOrphanNodes(graph),
+        ...detectTightCoupling(graph),
+        ...detectUnstableDependencies(graph),
+        ...detectScatteredResponsibility(graph),
+    ];
+    return {
+        analyzedAt: new Date().toISOString(),
+        totalSmells: smells.length,
+        smells,
+        healthScore: computeHealthScore(smells),
+    };
+};

package/dist/smells.test.d.ts

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

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

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

package/dist/smells.test.js

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "vitest";
+import { detectSmells } from "./smells";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
+const node = (id, kind = "module", contractOverrides = {}) => ({
+    id,
+    kind,
+    name: id,
+    summary: id,
+    contract: { ...emptyContract(), ...contractOverrides },
+    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,
+});
+const makeMethod = (name) => ({
+    name,
+    summary: `Does ${name}.`,
+    inputs: [],
+    outputs: [],
+    sideEffects: [],
+    calls: [],
+});
+describe("detectSmells", () => {
+    it("detects a god-node (critical)", () => {
+        const report = detectSmells(graph("GodNode", [
+            node("god", "class", {
+                responsibilities: ["r1", "r2", "r3", "r4", "r5"],
+                methods: Array.from({ length: 7 }, (_, i) => makeMethod(`method${i}`)),
+            }),
+        ], []));
+        expect(report.smells.some((s) => s.code === "god-node" && s.severity === "critical")).toBe(true);
+    });
+    it("does not flag a node with only methods but few responsibilities", () => {
+        const report = detectSmells(graph("MethodsOnly", [
+            node("methodsOnly", "class", {
+                responsibilities: ["r1"],
+                methods: Array.from({ length: 8 }, (_, i) => makeMethod(`m${i}`)),
+            }),
+        ], []));
+        expect(report.smells.some((s) => s.code === "god-node")).toBe(false);
+    });
+    it("does not flag a node with only responsibilities but few methods", () => {
+        const report = detectSmells(graph("ResponsibilitiesOnly", [
+            node("respOnly", "class", {
+                responsibilities: Array.from({ length: 6 }, (_, i) => `r${i}`),
+                methods: [makeMethod("single")],
+            }),
+        ], []));
+        expect(report.smells.some((s) => s.code === "god-node")).toBe(false);
+    });
+    it("detects orphan nodes (info)", () => {
+        const report = detectSmells(graph("Orphan", [node("lonely", "function")], []));
+        expect(report.smells.some((s) => s.code === "orphan-node" && s.severity === "info")).toBe(true);
+    });
+    it("returns health score 100 for a clean small graph", () => {
+        const report = detectSmells(graph("Clean", [node("A", "module"), node("B", "function")], [edge("A", "B")]));
+        expect(report.healthScore).toBe(100); // A→B edge means no orphans in connected graph
+    });
+    it("detects tight coupling between two nodes with 3+ edges", () => {
+        const report = detectSmells(graph("TightCoupling", [node("A", "module"), node("B", "module")], [
+            edge("A", "B"),
+            { from: "A", to: "B", kind: "imports", required: true, confidence: 1 },
+            edge("B", "A"),
+        ]));
+        expect(report.smells.some((s) => s.code === "tight-coupling" && s.severity === "warning")).toBe(true);
+    });
+    it("does not flag two nodes with fewer than 3 edges as tight coupling", () => {
+        const report = detectSmells(graph("NotTight", [node("A", "module"), node("B", "module")], [edge("A", "B"), edge("B", "A")]));
+        expect(report.smells.some((s) => s.code === "tight-coupling")).toBe(false);
+    });
+    it("detects scattered responsibility (info)", () => {
+        const report = detectSmells(graph("Scattered", [
+            node("scattered", "module", {
+                sideEffects: ["db-write", "email", "cache-invalidate", "log"],
+            }),
+        ], []));
+        expect(report.smells.some((s) => s.code === "scattered-responsibility" && s.severity === "info")).toBe(true);
+    });
+    it("health score decreases by correct penalty amounts", () => {
+        // god-node (critical = -15) + orphan-node (info = -3) = 82
+        const report = detectSmells(graph("Mixed", [
+            node("god", "class", {
+                responsibilities: ["r1", "r2", "r3", "r4", "r5"],
+                methods: Array.from({ length: 8 }, (_, i) => makeMethod(`m${i}`)),
+            }),
+            node("lonely", "function"),
+        ], []));
+        expect(report.healthScore).toBe(100 - 15 - 3 - 3); // god-node (critical -15) + god IS orphan (-3) + lonely orphan (-3) = 79
+    });
+    it("totalSmells equals the number of individual smell records", () => {
+        const report = detectSmells(graph("Count", [node("A", "module"), node("B", "function")], []));
+        expect(report.totalSmells).toBe(report.smells.length);
+    });
+    it("smell suggestion is always non-empty", () => {
+        const report = detectSmells(graph("Suggestions", [
+            node("god", "class", {
+                responsibilities: ["r1", "r2", "r3", "r4", "r5"],
+                methods: Array.from({ length: 8 }, (_, i) => makeMethod(`m${i}`)),
+            }),
+        ], []));
+        for (const smell of report.smells) {
+            expect(smell.suggestion.length).toBeGreaterThan(0);
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abhinav2203/codeflow-analysis",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,8 +21,8 @@
     "build": "tsc --outDir dist --declaration --declarationMap --noEmit false"
   },
   "dependencies": {
-    "@abhinav2203/codeflow-core": "workspace:*",
-    "@abhinav2203/codeflow-store": "workspace:*",
+    "@abhinav2203/codeflow-core": "^1.1.5",
+    "@abhinav2203/codeflow-store": "^1.0.13",
     "zod": "^3.0.0"
   },
   "devDependencies": {

package/src/app/api/analysis/cycles/route.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest";
 
 import { POST } from "../../../../handlers/cycles";
-import type { BlueprintGraph } from "@/lib/blueprint/schema";
-import { emptyContract } from "@/lib/blueprint/schema";
+import type { BlueprintGraph } from "@abhinav2203/codeflow-core/schema";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
 
 const minimalNode = (id: string): BlueprintGraph["nodes"][number] => ({
   id,

package/src/app/api/analysis/metrics/route.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest";
 
 import { POST } from "../../../../handlers/metrics";
-import type { BlueprintGraph } from "@/lib/blueprint/schema";
-import { emptyContract } from "@/lib/blueprint/schema";
+import type { BlueprintGraph } from "@abhinav2203/codeflow-core/schema";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
 
 const minimalNode = (
   id: string,

package/src/app/api/analysis/smells/route.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest";
 
 import { POST } from "../../../../handlers/smells";
-import type { BlueprintGraph } from "@/lib/blueprint/schema";
-import { emptyContract } from "@/lib/blueprint/schema";
+import type { BlueprintGraph, MethodSpec } from "@abhinav2203/codeflow-core/schema";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
 
 const baseGraph: BlueprintGraph = {
   projectName: "Smells Route Test",
@@ -14,13 +14,13 @@ const baseGraph: BlueprintGraph = {
   edges: [],
 };
 
-const makeMethod = (name: string) => ({
+const makeMethod = (name: string): MethodSpec => ({
   name,
   summary: `Does ${name}.`,
-  inputs: [] as { name: string; type: string; description?: string }[],
-  outputs: [] as { name: string; type: string; description?: string }[],
-  sideEffects: [] as string[],
-  calls: [] as { target: string; kind?: string; description?: string }[],
+  inputs: [],
+  outputs: [],
+  sideEffects: [],
+  calls: [],
 });
 
 describe("POST /api/analysis/smells", () => {

package/src/app/api/conflicts/route.test.ts

@@ -3,8 +3,8 @@ import path from "node:path";
 import { describe, expect, it } from "vitest";
 
 import { POST } from "../../../handlers/conflicts";
-import type { BlueprintGraph } from "@/lib/blueprint/schema";
-import { emptyContract } from "@/lib/blueprint/schema";
+import type { BlueprintGraph } from "@abhinav2203/codeflow-core/schema";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
 
 const fixturePath = path.resolve(process.cwd(), "test-fixtures/sample-repo");
 

package/src/app/api/refactor/detect/route.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest";
 
 import { POST } from "../../../../handlers/refactor-detect";
-import type { BlueprintGraph } from "@/lib/blueprint/schema";
-import { emptyContract } from "@/lib/blueprint/schema";
+import type { BlueprintGraph } from "@abhinav2203/codeflow-core/schema";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
 
 const graph: BlueprintGraph = {
   projectName: "Refactor Detect Route",

package/src/app/api/refactor/heal/route.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest";
 
 import { POST } from "../../../../handlers/refactor-heal";
-import type { BlueprintGraph } from "@/lib/blueprint/schema";
-import { emptyContract } from "@/lib/blueprint/schema";
+import type { BlueprintGraph } from "@abhinav2203/codeflow-core/schema";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
 
 const graph: BlueprintGraph = {
   projectName: "Refactor Heal Route",

package/src/conflicts.test.ts

@@ -3,8 +3,8 @@ import path from "node:path";
 import { describe, expect, it } from "vitest";
 
 import { detectGraphConflicts } from "./conflicts";
-import type { BlueprintGraph } from "@/lib/blueprint/schema";
-import { emptyContract } from "@/lib/blueprint/schema";
+import type { BlueprintGraph } from "@abhinav2203/codeflow-core/schema";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
 
 const fixturePath = path.resolve(process.cwd(), "test-fixtures/sample-repo");
 

package/src/conflicts.ts

@@ -1,12 +1,12 @@
 import path from "node:path";
 
-import { analyzeTypeScriptRepo } from "@/lib/blueprint/repo";
+import { analyzeTypeScriptRepo } from "@abhinav2203/codeflow-core/analyzer";
 import type {
   BlueprintGraph,
   BlueprintNode,
   ConflictRecord,
   ConflictReport,
-} from "@/lib/blueprint/schema";
+} from "@abhinav2203/codeflow-core/schema";
 
 const repoKeyForNode = (node: BlueprintNode): string =>
   `${node.kind}:${node.path ?? ""}:${node.name}`;

package/src/cycles.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest";
 
 import { detectCycles, hasCycles } from "./cycles";
-import type { BlueprintGraph } from "@/lib/blueprint/schema";
-import { emptyContract } from "@/lib/blueprint/schema";
+import type { BlueprintGraph } from "@abhinav2203/codeflow-core/schema";
+import { emptyContract } from "@abhinav2203/codeflow-core/schema";
 
 const node = (id: string): BlueprintGraph["nodes"][number] => ({
   id,

package/src/cycles.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import type { BlueprintGraph } from "@/lib/blueprint/schema";
+import type { BlueprintGraph } from "@abhinav2203/codeflow-core/schema";
 
 export const cycleSchema = z.object({
   nodeIds: z.array(z.string()),

package/src/handlers/conflicts.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 
 import { detectGraphConflicts } from "../conflicts";
-import { conflictCheckRequestSchema } from "@/lib/blueprint/schema";
+import { conflictCheckRequestSchema } from "@abhinav2203/codeflow-core/schema";
 
 /**
  * POST /api/conflicts

package/src/handlers/cycles.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 
 import { detectCycles, hasCycles } from "../cycles";
-import { blueprintGraphSchema } from "@/lib/blueprint/schema";
+import { blueprintGraphSchema } from "@abhinav2203/codeflow-core/schema";
 
 /**
  * POST /api/analysis/cycles

package/src/handlers/metrics.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 
 import { computeGraphMetrics } from "../metrics";
-import { blueprintGraphSchema } from "@/lib/blueprint/schema";
+import { blueprintGraphSchema } from "@abhinav2203/codeflow-core/schema";
 
 /**
  * POST /api/analysis/metrics

package/src/handlers/refactor-detect.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 
 import { detectDrift } from "../refactor";
-import { blueprintGraphSchema } from "@/lib/blueprint/schema";
+import { blueprintGraphSchema } from "@abhinav2203/codeflow-core/schema";
 
 /**
  * POST /api/refactor/detect

package/src/handlers/refactor-heal.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 
 import { detectDrift, healGraph } from "../refactor";
-import { blueprintGraphSchema } from "@/lib/blueprint/schema";
+import { blueprintGraphSchema } from "@abhinav2203/codeflow-core/schema";
 
 /**
  * POST /api/refactor/heal

package/src/handlers/smells.ts

@@ -1,7 +1,7 @@
 import { NextResponse } from "next/server";
 
 import { detectSmells } from "../smells";
-import { blueprintGraphSchema } from "@/lib/blueprint/schema";
+import { blueprintGraphSchema } from "@abhinav2203/codeflow-core/schema";
 
 /**
  * POST /api/analysis/smells