@unerr-ai/unerr 0.1.0 → 0.1.2

package/dist/__tests__/rule-evaluator.test.js

@@ -0,0 +1,280 @@
+/**
+ * Phase 10b TEST-02/03/04: Rule evaluator tests.
+ *
+ * Tests naming rule evaluation (regex against entity names).
+ * Structural tests are integration-level (require tree-sitter WASM).
+ */
+import { describe, expect, it, vi } from "vitest";
+// Mock web-tree-sitter to avoid resolution error in test environment
+vi.mock("web-tree-sitter", () => ({
+    default: {
+        init: vi.fn(),
+        Language: { load: vi.fn() },
+    },
+}));
+import { evaluateRules } from "../intelligence/rule-evaluator.js";
+function createMockLocalGraph(entities = []) {
+    return {
+        getEntitiesByFile: vi.fn().mockReturnValue(entities),
+        getEntity: vi.fn(),
+        getCallersOf: vi.fn().mockReturnValue([]),
+        getCalleesOf: vi.fn().mockReturnValue([]),
+        searchEntities: vi.fn().mockReturnValue([]),
+        getImports: vi.fn().mockReturnValue([]),
+        healthCheck: vi.fn().mockReturnValue({ status: "up", latencyMs: 0 }),
+        isLoaded: vi.fn().mockReturnValue(true),
+        loadSnapshot: vi.fn(),
+        loadRules: vi.fn(),
+        loadPatterns: vi.fn(),
+        hasRules: vi.fn().mockReturnValue(true),
+        getRules: vi.fn().mockReturnValue([]),
+        getPatterns: vi.fn().mockReturnValue([]),
+        loadRuleExceptions: vi.fn(),
+        getRuleExceptions: vi.fn().mockReturnValue([]),
+        getExpiringExceptions: vi.fn().mockReturnValue([]),
+    };
+}
+describe("evaluateRules", () => {
+    describe("naming engine", () => {
+        it("detects naming violations via regex", async () => {
+            const rules = [
+                {
+                    key: "rule-1",
+                    name: "PascalCase classes",
+                    scope: "repo",
+                    severity: "error",
+                    engine: "naming",
+                    query: "^[a-z]",
+                    message: "Classes must start with uppercase",
+                    file_glob: "",
+                    enabled: true,
+                    repo_id: "repo-1",
+                },
+            ];
+            const entities = [
+                {
+                    key: "cls1",
+                    kind: "class",
+                    name: "myClass",
+                    file_path: "src/foo.ts",
+                    start_line: 5,
+                    signature: "class myClass",
+                    body: "",
+                },
+                {
+                    key: "cls2",
+                    kind: "class",
+                    name: "MyClass",
+                    file_path: "src/foo.ts",
+                    start_line: 20,
+                    signature: "class MyClass",
+                    body: "",
+                },
+            ];
+            const localGraph = createMockLocalGraph(entities);
+            const result = await evaluateRules(rules, "src/foo.ts", "", localGraph);
+            expect(result.violations.length).toBe(1);
+            expect(result.violations[0]?.matchedCode).toBe("myClass");
+            expect(result.violations[0]?.severity).toBe("error");
+            expect(result._meta.engines.naming).toBe(1);
+        });
+        it("returns no violations when no entities match", async () => {
+            const rules = [
+                {
+                    key: "rule-1",
+                    name: "No test_ prefix",
+                    scope: "repo",
+                    severity: "warn",
+                    engine: "naming",
+                    query: "^test_",
+                    message: "Avoid test_ prefix",
+                    file_glob: "",
+                    enabled: true,
+                    repo_id: "repo-1",
+                },
+            ];
+            const entities = [
+                {
+                    key: "fn1",
+                    kind: "function",
+                    name: "doStuff",
+                    file_path: "src/foo.ts",
+                    start_line: 1,
+                    signature: "",
+                    body: "",
+                },
+            ];
+            const localGraph = createMockLocalGraph(entities);
+            const result = await evaluateRules(rules, "src/foo.ts", "", localGraph);
+            expect(result.violations.length).toBe(0);
+        });
+    });
+    describe("engine partitioning", () => {
+        it("skips semgrep and llm rules", async () => {
+            const rules = [
+                {
+                    key: "rule-semgrep",
+                    name: "Semgrep rule",
+                    scope: "repo",
+                    severity: "warn",
+                    engine: "semgrep",
+                    query: "pattern-not: $X",
+                    message: "Semgrep",
+                    file_glob: "",
+                    enabled: true,
+                    repo_id: "repo-1",
+                },
+                {
+                    key: "rule-llm",
+                    name: "LLM rule",
+                    scope: "repo",
+                    severity: "info",
+                    engine: "llm",
+                    query: "review for security",
+                    message: "LLM review",
+                    file_glob: "",
+                    enabled: true,
+                    repo_id: "repo-1",
+                },
+            ];
+            const localGraph = createMockLocalGraph();
+            const result = await evaluateRules(rules, "src/foo.ts", "const x = 1", localGraph);
+            expect(result.violations.length).toBe(0);
+            expect(result._meta.skippedRules).toBe(2);
+            expect(result._meta.evaluatedRules).toBe(0);
+        });
+        it("skips disabled rules", async () => {
+            const rules = [
+                {
+                    key: "rule-disabled",
+                    name: "Disabled rule",
+                    scope: "repo",
+                    severity: "warn",
+                    engine: "naming",
+                    query: ".*",
+                    message: "Match all",
+                    file_glob: "",
+                    enabled: false,
+                    repo_id: "repo-1",
+                },
+            ];
+            const localGraph = createMockLocalGraph([
+                {
+                    key: "fn1",
+                    kind: "function",
+                    name: "anything",
+                    file_path: "src/foo.ts",
+                    start_line: 1,
+                    signature: "",
+                    body: "",
+                },
+            ]);
+            const result = await evaluateRules(rules, "src/foo.ts", "", localGraph);
+            expect(result.violations.length).toBe(0);
+            expect(result._meta.skippedRules).toBe(1);
+        });
+    });
+    describe("structural engine (graceful degradation)", () => {
+        it("returns empty violations when tree-sitter is not available", async () => {
+            const rules = [
+                {
+                    key: "rule-struct",
+                    name: "Structural rule",
+                    scope: "repo",
+                    severity: "warn",
+                    engine: "structural",
+                    query: "call_expression",
+                    message: "Found call",
+                    file_glob: "",
+                    enabled: true,
+                    repo_id: "repo-1",
+                },
+            ];
+            const localGraph = createMockLocalGraph();
+            const result = await evaluateRules(rules, "src/foo.ts", "console.log('hello')", localGraph);
+            // Without tree-sitter WASM files installed, should gracefully return 0 violations
+            expect(result._meta.engines.structural).toBe(1);
+            expect(result._meta.source).toBe("local");
+        });
+        it("handles unsupported file extensions gracefully", async () => {
+            const rules = [
+                {
+                    key: "rule-struct",
+                    name: "Structural rule",
+                    scope: "repo",
+                    severity: "warn",
+                    engine: "structural",
+                    query: "call_expression",
+                    message: "Found call",
+                    file_glob: "",
+                    enabled: true,
+                    repo_id: "repo-1",
+                },
+            ];
+            const localGraph = createMockLocalGraph();
+            const result = await evaluateRules(rules, "src/foo.rb", "puts 'hello'", localGraph);
+            expect(result.violations.length).toBe(0);
+        });
+    });
+    describe("meta information", () => {
+        it("reports correct engine counts", async () => {
+            const rules = [
+                {
+                    key: "r1",
+                    name: "R1",
+                    scope: "repo",
+                    severity: "warn",
+                    engine: "naming",
+                    query: "^_",
+                    message: "",
+                    file_glob: "",
+                    enabled: true,
+                    repo_id: "r",
+                },
+                {
+                    key: "r2",
+                    name: "R2",
+                    scope: "repo",
+                    severity: "warn",
+                    engine: "structural",
+                    query: "fn_def",
+                    message: "",
+                    file_glob: "",
+                    enabled: true,
+                    repo_id: "r",
+                },
+                {
+                    key: "r3",
+                    name: "R3",
+                    scope: "repo",
+                    severity: "warn",
+                    engine: "semgrep",
+                    query: "p",
+                    message: "",
+                    file_glob: "",
+                    enabled: true,
+                    repo_id: "r",
+                },
+                {
+                    key: "r4",
+                    name: "R4",
+                    scope: "repo",
+                    severity: "warn",
+                    engine: "naming",
+                    query: "^x",
+                    message: "",
+                    file_glob: "",
+                    enabled: false,
+                    repo_id: "r",
+                },
+            ];
+            const localGraph = createMockLocalGraph();
+            const result = await evaluateRules(rules, "src/foo.ts", "", localGraph);
+            expect(result._meta.engines.naming).toBe(1);
+            expect(result._meta.engines.structural).toBe(1);
+            expect(result._meta.engines.skipped).toBe(2); // semgrep + disabled
+            expect(result._meta.evaluatedRules).toBe(2);
+            expect(result._meta.skippedRules).toBe(2);
+        });
+    });
+});

package/dist/__tests__/scip-decoder.test.js

@@ -0,0 +1,49 @@
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { decodeScipOutput } from "../intelligence/indexer/scip/decoder.js";
+let tempDir;
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-scip-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+});
+afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+});
+describe("SCIP Decoder", () => {
+    it("handles empty file gracefully", async () => {
+        const filePath = join(tempDir, "empty.scip");
+        writeFileSync(filePath, "");
+        const result = await decodeScipOutput(filePath);
+        expect(result.documents).toHaveLength(0);
+        expect(result.symbolCount).toBe(0);
+        expect(result.durationMs).toBeGreaterThanOrEqual(0);
+    });
+    it("handles binary protobuf data without crashing", async () => {
+        const filePath = join(tempDir, "binary.scip");
+        const randomData = Buffer.alloc(1024);
+        for (let i = 0; i < 1024; i++) {
+            randomData[i] = Math.floor(Math.random() * 256);
+        }
+        writeFileSync(filePath, randomData);
+        const result = await decodeScipOutput(filePath);
+        expect(result.durationMs).toBeGreaterThanOrEqual(0);
+    });
+    it("produces valid decode result structure", async () => {
+        const filePath = join(tempDir, "valid.scip");
+        writeFileSync(filePath, Buffer.from([0x0a, 0x02, 0x22, 0x00]));
+        const result = await decodeScipOutput(filePath);
+        expect(typeof result.symbolCount).toBe("number");
+        expect(typeof result.definitionCount).toBe("number");
+        expect(typeof result.referenceCount).toBe("number");
+        expect(Array.isArray(result.documents)).toBe(true);
+    });
+    it("reports duration in milliseconds", async () => {
+        const filePath = join(tempDir, "timing.scip");
+        writeFileSync(filePath, Buffer.alloc(100));
+        const result = await decodeScipOutput(filePath);
+        expect(result.durationMs).toBeGreaterThanOrEqual(0);
+        expect(result.durationMs).toBeLessThan(5000);
+    });
+});

package/dist/__tests__/scip-downloader.test.js

@@ -0,0 +1,201 @@
+import { describe, expect, it } from "vitest";
+import { buildDownloadUrl, getAutoDownloadLanguages, getCachedBinaryPath, getDownloadSpec, getManualInstallInstructions, getScipBinDir, isAutoDownloadSupported, resolvePlatform, } from "../intelligence/indexer/scip/downloader.js";
+describe("SCIP Downloader", () => {
+    describe("resolvePlatform", () => {
+        it("returns valid platform identifiers", () => {
+            const platform = resolvePlatform();
+            expect(platform.os).toBeDefined();
+            expect(platform.arch).toBeDefined();
+            expect(platform.rustTriple).toBeDefined();
+            expect(platform.nodeArch).toBeDefined();
+            expect(["darwin", "linux", "windows"]).toContain(platform.os);
+            expect(["x86_64", "aarch64"]).toContain(platform.arch);
+        });
+        it("returns correct rust triple for current platform", () => {
+            const platform = resolvePlatform();
+            expect(platform.rustTriple).toMatch(/^(x86_64|aarch64)-(apple-darwin|unknown-linux-gnu|pc-windows-msvc)$/);
+        });
+    });
+    describe("getAutoDownloadLanguages", () => {
+        it("returns exactly the 5 auto-download languages (not bundled ones)", () => {
+            const langs = getAutoDownloadLanguages();
+            expect(langs).toContain("go");
+            expect(langs).toContain("java");
+            expect(langs).toContain("rust");
+            expect(langs).toContain("ruby");
+            expect(langs).toContain("cpp");
+            expect(langs).toHaveLength(5);
+            // Python is bundled as npm dep, not auto-downloaded
+            expect(langs).not.toContain("python");
+        });
+    });
+    describe("isAutoDownloadSupported", () => {
+        it("returns true for auto-download languages", () => {
+            expect(isAutoDownloadSupported("go")).toBe(true);
+            expect(isAutoDownloadSupported("java")).toBe(true);
+            expect(isAutoDownloadSupported("rust")).toBe(true);
+            expect(isAutoDownloadSupported("ruby")).toBe(true);
+            expect(isAutoDownloadSupported("cpp")).toBe(true);
+        });
+        it("returns false for bundled and unsupported languages", () => {
+            // Bundled as npm deps — not in downloader
+            expect(isAutoDownloadSupported("typescript")).toBe(false);
+            expect(isAutoDownloadSupported("python")).toBe(false);
+            // Not supported at all
+            expect(isAutoDownloadSupported("csharp")).toBe(false);
+        });
+    });
+    describe("getDownloadSpec", () => {
+        it("returns spec for go with correct repo", () => {
+            const spec = getDownloadSpec("go");
+            expect(spec).not.toBeNull();
+            expect(spec.binaryName).toBe("scip-go");
+            expect(spec.repo).toBe("scip-code/scip-go");
+        });
+        it("returns spec for rust with correct binary name", () => {
+            const spec = getDownloadSpec("rust");
+            expect(spec).not.toBeNull();
+            expect(spec.binaryName).toBe("rust-analyzer");
+            expect(spec.repo).toBe("rust-lang/rust-analyzer");
+        });
+        it("returns spec for java", () => {
+            const spec = getDownloadSpec("java");
+            expect(spec).not.toBeNull();
+            expect(spec.binaryName).toBe("scip-java");
+            expect(spec.repo).toBe("sourcegraph/scip-java");
+        });
+        it("returns spec for ruby with correct binary name", () => {
+            const spec = getDownloadSpec("ruby");
+            expect(spec).not.toBeNull();
+            expect(spec.binaryName).toBe("scip-ruby");
+            expect(spec.repo).toBe("sourcegraph/scip-ruby");
+        });
+        it("returns spec for cpp with correct binary name", () => {
+            const spec = getDownloadSpec("cpp");
+            expect(spec).not.toBeNull();
+            expect(spec.binaryName).toBe("scip-clang");
+            expect(spec.repo).toBe("sourcegraph/scip-clang");
+        });
+        it("returns null for bundled and unsupported languages", () => {
+            expect(getDownloadSpec("typescript")).toBeNull();
+            expect(getDownloadSpec("python")).toBeNull();
+        });
+    });
+    describe("getManualInstallInstructions", () => {
+        it("returns instructions for each auto-download language", () => {
+            expect(getManualInstallInstructions("go")).toContain("go install");
+            expect(getManualInstallInstructions("rust")).toContain("rustup");
+            expect(getManualInstallInstructions("java")).toContain("scip-java");
+        });
+        it("returns null for bundled and unsupported languages", () => {
+            expect(getManualInstallInstructions("typescript")).toBeNull();
+            expect(getManualInstallInstructions("python")).toBeNull();
+        });
+    });
+    describe("buildDownloadUrl", () => {
+        it("builds correct URL for rust-analyzer with rust triple", () => {
+            const spec = getDownloadSpec("rust");
+            const platform = {
+                os: "darwin",
+                arch: "aarch64",
+                nodeArch: "arm64",
+                rustTriple: "aarch64-apple-darwin",
+            };
+            const url = buildDownloadUrl(spec, platform, "2024-01-01");
+            expect(url).toBe("https://github.com/rust-lang/rust-analyzer/releases/download/2024-01-01/rust-analyzer-aarch64-apple-darwin.gz");
+        });
+        it("builds correct URL for go on linux arm64", () => {
+            const spec = getDownloadSpec("go");
+            const platform = {
+                os: "linux",
+                arch: "aarch64",
+                nodeArch: "arm64",
+                rustTriple: "aarch64-unknown-linux-gnu",
+            };
+            const url = buildDownloadUrl(spec, platform, "v0.5.0");
+            expect(url).toBe("https://github.com/scip-code/scip-go/releases/download/v0.5.0/scip-go-linux-arm64.tar.gz");
+        });
+        it("returns null for unsupported platform combinations", () => {
+            const spec = getDownloadSpec("go");
+            // go has no darwin-amd64 build
+            const platform = {
+                os: "darwin",
+                arch: "x86_64",
+                nodeArch: "x64",
+                rustTriple: "x86_64-apple-darwin",
+            };
+            const url = buildDownloadUrl(spec, platform, "v0.5.0");
+            expect(url).toBeNull();
+        });
+        it("returns null for windows", () => {
+            const spec = getDownloadSpec("rust");
+            const platform = {
+                os: "windows",
+                arch: "x86_64",
+                nodeArch: "x64",
+                rustTriple: "x86_64-pc-windows-msvc",
+            };
+            const url = buildDownloadUrl(spec, platform, "2024-01-01");
+            expect(url).toBeNull();
+        });
+        it("builds correct URL for scip-ruby on darwin arm64", () => {
+            const spec = getDownloadSpec("ruby");
+            const platform = {
+                os: "darwin",
+                arch: "aarch64",
+                nodeArch: "arm64",
+                rustTriple: "aarch64-apple-darwin",
+            };
+            const url = buildDownloadUrl(spec, platform, "scip-ruby-v0.4.7");
+            expect(url).toBe("https://github.com/sourcegraph/scip-ruby/releases/download/scip-ruby-v0.4.7/scip-ruby-arm64-darwin");
+        });
+        it("builds correct URL for scip-clang on linux x64", () => {
+            const spec = getDownloadSpec("cpp");
+            const platform = {
+                os: "linux",
+                arch: "x86_64",
+                nodeArch: "x64",
+                rustTriple: "x86_64-unknown-linux-gnu",
+            };
+            const url = buildDownloadUrl(spec, platform, "v0.4.0");
+            expect(url).toBe("https://github.com/sourcegraph/scip-clang/releases/download/v0.4.0/scip-clang-x86_64-linux");
+        });
+        it("returns null for scip-ruby on darwin x64 (no build available)", () => {
+            const spec = getDownloadSpec("ruby");
+            const platform = {
+                os: "darwin",
+                arch: "x86_64",
+                nodeArch: "x64",
+                rustTriple: "x86_64-apple-darwin",
+            };
+            const url = buildDownloadUrl(spec, platform, "scip-ruby-v0.4.7");
+            expect(url).toBeNull();
+        });
+        it("returns null for scip-clang on linux arm64 (no build available)", () => {
+            const spec = getDownloadSpec("cpp");
+            const platform = {
+                os: "linux",
+                arch: "aarch64",
+                nodeArch: "arm64",
+                rustTriple: "aarch64-unknown-linux-gnu",
+            };
+            const url = buildDownloadUrl(spec, platform, "v0.4.0");
+            expect(url).toBeNull();
+        });
+    });
+    describe("getCachedBinaryPath", () => {
+        it("returns null when no cached binary exists for unsupported language", () => {
+            expect(getCachedBinaryPath("haskell")).toBeNull();
+        });
+        it("returns null for unsupported languages", () => {
+            expect(getCachedBinaryPath("typescript")).toBeNull();
+        });
+    });
+    describe("getScipBinDir", () => {
+        it("returns path under ~/.unerr/bin", () => {
+            const binDir = getScipBinDir();
+            expect(binDir).toContain(".unerr");
+            expect(binDir).toContain("bin");
+        });
+    });
+});

package/dist/__tests__/scip-merger.test.js

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "vitest";
+import { applyScipFallback, classifyScipError, } from "../intelligence/indexer/scip/fallback.js";
+import { mergeScipResults, } from "../intelligence/indexer/scip/merger.js";
+describe("SCIP Merger (L2.4)", () => {
+    it("upgrades edges when SCIP evidence exists", () => {
+        const edges = [
+            {
+                from_key: "a",
+                to_key: "b",
+                type: "calls",
+                file_path: "src/main.ts",
+                line: 10,
+            },
+            {
+                from_key: "c",
+                to_key: "d",
+                type: "calls",
+                file_path: "src/utils.ts",
+                line: 20,
+            },
+        ];
+        const scipResult = {
+            documents: [
+                {
+                    relativePath: "src/main.ts",
+                    symbols: [
+                        {
+                            symbol: "scip-typescript npm test 0.1.0 src/`main.ts`/b.",
+                            filePath: "src/main.ts",
+                            line: 10,
+                            isDefinition: true,
+                        },
+                    ],
+                },
+            ],
+            symbolCount: 1,
+            definitionCount: 1,
+            referenceCount: 0,
+            durationMs: 100,
+        };
+        // Provide entity info so merger can match by (name, file_path)
+        const entities = [
+            { key: "b", name: "b", file_path: "src/main.ts" },
+            { key: "d", name: "d", file_path: "src/utils.ts" },
+        ];
+        const { edges: enriched, result } = mergeScipResults(edges, scipResult, entities);
+        expect(enriched).toHaveLength(2);
+        expect(result.edgesUpgraded).toBeGreaterThanOrEqual(1);
+        const upgraded = enriched.find((e) => e.scipVerified);
+        if (upgraded) {
+            expect(upgraded.confidence).toBe("compiler-verified");
+        }
+    });
+    it("preserves structural confidence when no SCIP evidence", () => {
+        const edges = [
+            {
+                from_key: "x",
+                to_key: "y",
+                type: "contains",
+                file_path: "src/a.ts",
+                line: 5,
+            },
+        ];
+        const scipResult = {
+            documents: [],
+            symbolCount: 0,
+            definitionCount: 0,
+            referenceCount: 0,
+            durationMs: 0,
+        };
+        const { edges: enriched } = mergeScipResults(edges, scipResult);
+        expect(enriched[0]?.confidence).toBe("structural");
+        expect(enriched[0]?.scipVerified).toBe(false);
+    });
+    it("handles empty edge list", () => {
+        const { edges, result } = mergeScipResults([], {
+            documents: [],
+            symbolCount: 0,
+            definitionCount: 0,
+            referenceCount: 0,
+            durationMs: 0,
+        });
+        expect(edges).toHaveLength(0);
+        expect(result.edgesUpgraded).toBe(0);
+    });
+});
+describe("SCIP Fallback (L2.9)", () => {
+    it("applies structural confidence on fallback", () => {
+        const edges = [
+            { from_key: "a", to_key: "b", type: "calls", file_path: "f.ts", line: 1 },
+        ];
+        const result = applyScipFallback(edges, "binary not found");
+        expect(result.level).toBe("unavailable");
+        expect(result.edges[0]?.confidence).toBe("structural");
+        expect(result.edges[0]?.scipVerified).toBe(false);
+    });
+    it("classifies error types correctly", () => {
+        expect(classifyScipError("ENOENT: not found")).toBe("unavailable");
+        expect(classifyScipError("timeout exceeded")).toBe("partial");
+        expect(classifyScipError("protobuf decode failed")).toBe("partial");
+        expect(classifyScipError("unknown error")).toBe("unavailable");
+    });
+});