@unerr-ai/unerr 0.1.0 → 0.1.2

package/dist/__tests__/sprint3-intelligence.test.js

@@ -0,0 +1,297 @@
+/**
+ * Sprint 3: Local Intelligence Deepening — tests for blast radius entities,
+ * convention matching, health grade enhancements, and prefetch.
+ */
+import { describe, expect, it, vi } from "vitest";
+import { checkFileStructure, checkImportDirection, checkNamingConventions, matchConventions, } from "../intelligence/convention-matcher.js";
+// ── 3.1: Blast Radius Entities ────────────────────────────────────
+describe("Sprint 3.1: getBlastRadiusEntities", () => {
+    it("returns empty array when no callers exist", () => {
+        // Simulate: entity with no callers
+        const mockGraph = createMockGraphStore({
+            transitiveRows: [],
+            entityRows: new Map(),
+        });
+        const result = mockGraph.getBlastRadiusEntities("isolated-fn", 2);
+        expect(result).toEqual([]);
+    });
+    it("returns entities with depth from recursive traversal", () => {
+        const mockGraph = createMockGraphStore({
+            transitiveRows: [
+                ["caller-a", 1],
+                ["caller-b", 1],
+                ["caller-c", 2],
+            ],
+            entityRows: new Map([
+                ["caller-a", ["caller-a", "callerA", "src/a.ts"]],
+                ["caller-b", ["caller-b", "callerB", "src/b.ts"]],
+                ["caller-c", ["caller-c", "callerC", "src/c.ts"]],
+            ]),
+        });
+        const result = mockGraph.getBlastRadiusEntities("target-fn", 2);
+        expect(result).toHaveLength(3);
+        expect(result[0]).toEqual({
+            key: "caller-a",
+            name: "callerA",
+            file: "src/a.ts",
+            depth: 1,
+        });
+        expect(result[2]).toEqual({
+            key: "caller-c",
+            name: "callerC",
+            file: "src/c.ts",
+            depth: 2,
+        });
+    });
+    it("excludes the source entity from results", () => {
+        const mockGraph = createMockGraphStore({
+            transitiveRows: [
+                ["target-fn", 1], // self-reference
+                ["caller-a", 1],
+            ],
+            entityRows: new Map([["caller-a", ["caller-a", "callerA", "src/a.ts"]]]),
+        });
+        const result = mockGraph.getBlastRadiusEntities("target-fn", 2);
+        expect(result).toHaveLength(1);
+        expect(result[0]?.key).toBe("caller-a");
+    });
+    it("uses minimum depth when entity appears at multiple depths", () => {
+        const mockGraph = createMockGraphStore({
+            transitiveRows: [
+                ["caller-a", 2],
+                ["caller-a", 1], // same entity at closer depth
+            ],
+            entityRows: new Map([["caller-a", ["caller-a", "callerA", "src/a.ts"]]]),
+        });
+        const result = mockGraph.getBlastRadiusEntities("target-fn", 3);
+        expect(result).toHaveLength(1);
+        expect(result[0]?.depth).toBe(1);
+    });
+});
+// ── 3.2: Convention Pattern Matching ──────────────────────────────
+describe("Sprint 3.2: Convention Pattern Matching", () => {
+    describe("checkNamingConventions", () => {
+        it("detects non-PascalCase class names", () => {
+            const entities = [
+                makeEntity("myClass", "class", "src/foo.ts"),
+            ];
+            const violations = checkNamingConventions(entities);
+            expect(violations).toHaveLength(1);
+            expect(violations[0]?.type).toBe("naming");
+            expect(violations[0]?.message).toContain("myClass");
+        });
+        it("passes PascalCase class names", () => {
+            const entities = [
+                makeEntity("MyClass", "class", "src/foo.ts"),
+            ];
+            const violations = checkNamingConventions(entities);
+            expect(violations).toHaveLength(0);
+        });
+        it("detects PascalCase function names", () => {
+            const entities = [
+                makeEntity("DoSomething", "function", "src/foo.ts"),
+            ];
+            const violations = checkNamingConventions(entities);
+            expect(violations).toHaveLength(1);
+            expect(violations[0]?.message).toContain("DoSomething");
+        });
+        it("passes camelCase function names", () => {
+            const entities = [
+                makeEntity("doSomething", "function", "src/foo.ts"),
+            ];
+            const violations = checkNamingConventions(entities);
+            expect(violations).toHaveLength(0);
+        });
+    });
+    describe("checkFileStructure", () => {
+        it("flags missing test file", async () => {
+            const graph = createConventionGraph({ hasTestFile: false });
+            const violations = await checkFileStructure("src/service.ts", graph);
+            expect(violations).toHaveLength(1);
+            expect(violations[0]?.type).toBe("file_structure");
+            expect(violations[0]?.message).toContain(".test.ts");
+        });
+        it("passes when test file exists", async () => {
+            const graph = createConventionGraph({ hasTestFile: true });
+            const violations = await checkFileStructure("src/service.ts", graph);
+            expect(violations).toHaveLength(0);
+        });
+        it("skips test files themselves", async () => {
+            const graph = createConventionGraph({ hasTestFile: false });
+            const violations = await checkFileStructure("src/service.test.ts", graph);
+            expect(violations).toHaveLength(0);
+        });
+    });
+    describe("checkImportDirection", () => {
+        it("flags service importing from controller", async () => {
+            const graph = createConventionGraph({
+                imports: [{ imported_file: "src/controllers/userCtrl.ts" }],
+            });
+            const violations = await checkImportDirection("src/services/userService.ts", graph);
+            expect(violations).toHaveLength(1);
+            expect(violations[0]?.type).toBe("import_direction");
+            expect(violations[0]?.severity).toBe("error");
+        });
+        it("passes when import direction is valid", async () => {
+            const graph = createConventionGraph({
+                imports: [{ imported_file: "src/utils/helper.ts" }],
+            });
+            const violations = await checkImportDirection("src/services/userService.ts", graph);
+            expect(violations).toHaveLength(0);
+        });
+    });
+    describe("matchConventions (composite)", () => {
+        it("runs all checks and aggregates violations", async () => {
+            const graph = createConventionGraph({
+                hasTestFile: false,
+                entities: [makeEntity("myBadClass", "class", "src/services/bad.ts")],
+                imports: [{ imported_file: "src/controllers/ctrl.ts" }],
+            });
+            const violations = await matchConventions("src/services/bad.ts", graph);
+            // Naming (class) + file structure + import direction
+            expect(violations.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+});
+// ── 3.3: Health Grade Enhancement ─────────────────────────────────
+describe("Sprint 3.3: Health Grade Enhancement", () => {
+    it("HealthGradeResult includes new fields", async () => {
+        const { computeHealthGrade } = await import("../intelligence/health-grade.js");
+        const db = createHealthGradeDb({
+            entities: 100,
+            edges: 200,
+            rules: 5,
+            deadFunctions: 10,
+        });
+        const result = await computeHealthGrade(db);
+        expect(result.score).toBeGreaterThan(0);
+        expect(result.grade).toBeDefined();
+        expect(result.conventionAdherence).toBeDefined();
+        expect(result.maxImportDepth).toBeDefined();
+    });
+    it("circular deps reduce health score", async () => {
+        const { computeHealthGrade } = await import("../intelligence/health-grade.js");
+        const dbNoCycles = createHealthGradeDb({ entities: 100, edges: 200 });
+        const dbWithCycles = createHealthGradeDb({
+            entities: 100,
+            edges: 200,
+            circularDeps: [["a", "b"]],
+        });
+        const scoreNoCycles = (await computeHealthGrade(dbNoCycles)).score;
+        const scoreWithCycles = (await computeHealthGrade(dbWithCycles)).score;
+        expect(scoreWithCycles).toBeLessThanOrEqual(scoreNoCycles);
+    });
+});
+// ── Helpers ───────────────────────────────────────────────────────
+function makeEntity(name, kind, filePath) {
+    return {
+        key: `${filePath}:${name}`,
+        kind,
+        name,
+        file_path: filePath,
+        start_line: 1,
+        end_line: 0,
+        signature: `${name}()`,
+        body: "",
+        fan_in: 0,
+        fan_out: 0,
+        community: -1,
+        risk_level: "normal",
+    };
+}
+function createMockGraphStore(opts) {
+    return {
+        getBlastRadiusEntities(entityKey, maxDepth = 2) {
+            const depthMap = new Map();
+            for (const row of opts.transitiveRows) {
+                const key = row[0];
+                const depth = row[1];
+                if (key === entityKey)
+                    continue;
+                const existing = depthMap.get(key);
+                if (existing === undefined || depth < existing) {
+                    depthMap.set(key, depth);
+                }
+            }
+            const entities = [];
+            for (const [key, depth] of depthMap) {
+                const row = opts.entityRows.get(key);
+                if (row) {
+                    entities.push({
+                        key,
+                        name: row[1],
+                        file: row[2],
+                        depth,
+                    });
+                }
+            }
+            entities.sort((a, b) => a.depth - b.depth || a.key.localeCompare(b.key));
+            return entities;
+        },
+    };
+}
+function createConventionGraph(opts) {
+    return {
+        getEntitiesByFile: vi.fn().mockImplementation((filePath) => {
+            // If checking for test sibling and hasTestFile is true, return entities
+            if (opts?.hasTestFile && filePath.includes(".test.")) {
+                return [makeEntity("testFn", "function", filePath)];
+            }
+            return opts?.entities ?? [];
+        }),
+        getImports: vi.fn().mockReturnValue(opts?.imports ?? []),
+    };
+}
+function createHealthGradeDb(opts) {
+    const entityCount = opts?.entities ?? 50;
+    const edgeCount = opts?.edges ?? 100;
+    const ruleCount = opts?.rules ?? 0;
+    const deadFnCount = opts?.deadFunctions ?? 0;
+    const circularDeps = opts?.circularDeps ?? [];
+    return {
+        async run(query, _params) {
+            // Count queries
+            if (query.includes("count(key)") && query.includes("*entities{")) {
+                return { rows: [[entityCount]] };
+            }
+            if (query.includes("count(from_key)") && query.includes("*edges[")) {
+                return { rows: [[edgeCount]] };
+            }
+            if (query.includes("count(key)") && query.includes("*rules[")) {
+                return { rows: [[ruleCount]] };
+            }
+            // Dead functions
+            if (query.includes('kind = "function"') &&
+                query.includes("fan_in == 0")) {
+                const rows = [];
+                for (let i = 0; i < deadFnCount; i++) {
+                    rows.push([`dead-fn-${i}`, `deadFn${i}`, `src/dead${i}.ts`, 0]);
+                }
+                return { rows };
+            }
+            // High risk entities
+            if (query.includes('risk_level == "high"')) {
+                return { rows: [] };
+            }
+            // Circular deps (2-hop)
+            if (query.includes("*edges[a, b") && query.includes("*edges[b, a")) {
+                return {
+                    rows: circularDeps.map((c) => [c[0], c[1]]),
+                };
+            }
+            // Max import depth
+            if (query.includes("max(depth)")) {
+                return { rows: [[3]] };
+            }
+            // Convention adherence
+            if (query.includes("*patterns[") && query.includes("naming")) {
+                return { rows: [] };
+            }
+            // Drift impact
+            if (query.includes("*drift_overlay[") && query.includes("fi > 5")) {
+                return { rows: [[0]] };
+            }
+            return { rows: [] };
+        },
+    };
+}

package/dist/__tests__/sprint5-mcp-server.test.js

@@ -0,0 +1,136 @@
+/**
+ * Sprint 5/E: Standalone MCP Server Package — tests for the workspace package
+ * structure, server factory, and IDE auto-configuration.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { checkIdeConfig, repairIdeConfig } from "../commands/config-verify.js";
+describe("Sprint E: MCP Package Structure", () => {
+    it("packages/mcp/src/server.ts exists", () => {
+        const serverPath = path.join(process.cwd(), "packages", "mcp", "src", "server.ts");
+        expect(fs.existsSync(serverPath)).toBe(true);
+    });
+    it("server.ts exports createMcpServer function", () => {
+        const serverPath = path.join(process.cwd(), "packages", "mcp", "src", "server.ts");
+        const content = fs.readFileSync(serverPath, "utf-8");
+        expect(content).toContain("export function createMcpServer");
+    });
+    it("types.ts exports McpToolDefinition interface", () => {
+        const typesPath = path.join(process.cwd(), "packages", "mcp", "src", "types.ts");
+        const content = fs.readFileSync(typesPath, "utf-8");
+        expect(content).toContain("McpToolDefinition");
+        expect(content).toContain("McpToolHandler");
+        expect(content).toContain("McpServerConfig");
+    });
+    it("index.ts barrel exports server and types", () => {
+        const indexPath = path.join(process.cwd(), "packages", "mcp", "src", "index.ts");
+        const content = fs.readFileSync(indexPath, "utf-8");
+        expect(content).toContain("createMcpServer");
+        expect(content).toContain("McpServerConfig");
+    });
+    it("STDIO transport exists", () => {
+        const stdioPath = path.join(process.cwd(), "packages", "mcp", "src", "transports", "stdio.ts");
+        expect(fs.existsSync(stdioPath)).toBe(true);
+    });
+    it("HTTP transport exists", () => {
+        const httpPath = path.join(process.cwd(), "packages", "mcp", "src", "transports", "http.ts");
+        expect(fs.existsSync(httpPath)).toBe(true);
+    });
+    it("package.json has correct name and exports", () => {
+        const pkgPath = path.join(process.cwd(), "packages", "mcp", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        expect(pkg.name).toBe("@unerr/unerr-mcp");
+        expect(pkg.type).toBe("module");
+        expect(pkg.exports["."]).toBeDefined();
+        expect(pkg.exports["./transports/stdio"]).toBeDefined();
+        expect(pkg.exports["./transports/http"]).toBeDefined();
+    });
+});
+describe("Sprint 5.4: IDE Auto-Configuration", () => {
+    it("checkIdeConfig detects missing MCP config", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "unerr-test-ide-"));
+        try {
+            const configPath = path.join(tmpDir, ".cursor", "mcp.json");
+            const result = checkIdeConfig("cursor", configPath);
+            expect(result.configured).toBe(false);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("repairIdeConfig creates config for Cursor", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "unerr-test-rep-"));
+        try {
+            const configPath = path.join(tmpDir, ".cursor", "mcp.json");
+            repairIdeConfig("cursor", configPath);
+            expect(fs.existsSync(configPath)).toBe(true);
+            const content = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            expect(content.mcpServers).toBeDefined();
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("repairIdeConfig creates config for Claude Code", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "unerr-test-cc-"));
+        try {
+            const configPath = path.join(tmpDir, ".mcp.json");
+            repairIdeConfig("claude-code", configPath);
+            expect(fs.existsSync(configPath)).toBe(true);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("repairIdeConfig creates config for VS Code", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "unerr-test-vsc-"));
+        try {
+            const configPath = path.join(tmpDir, ".vscode", "mcp.json");
+            repairIdeConfig("vscode", configPath);
+            expect(fs.existsSync(configPath)).toBe(true);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("checkIdeConfig detects existing config", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "unerr-test-ex-"));
+        try {
+            const configPath = path.join(tmpDir, ".cursor", "mcp.json");
+            repairIdeConfig("cursor", configPath);
+            const result = checkIdeConfig("cursor", configPath);
+            expect(result.configured).toBe(true);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("repairIdeConfig is idempotent", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "unerr-test-id-"));
+        try {
+            const configPath = path.join(tmpDir, ".cursor", "mcp.json");
+            repairIdeConfig("cursor", configPath);
+            const before = fs.readFileSync(configPath, "utf-8");
+            repairIdeConfig("cursor", configPath);
+            const after = fs.readFileSync(configPath, "utf-8");
+            expect(JSON.parse(before)).toEqual(JSON.parse(after));
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("checkIdeConfig supports windsurf IDE", () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "unerr-test-ws-"));
+        try {
+            const configPath = path.join(tmpDir, ".windsurf", "mcp.json");
+            repairIdeConfig("windsurf", configPath);
+            const result = checkIdeConfig("windsurf", configPath);
+            expect(result.configured).toBe(true);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});