@unerr-ai/unerr 0.1.6 → 0.1.7

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

@@ -1,297 +0,0 @@
-/**
- * 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

@@ -1,136 +0,0 @@
-/**
- * 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 });
-        }
-    });
-});