@unerr-ai/unerr 0.1.6 → 0.1.7

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

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

@@ -1,49 +0,0 @@
-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

@@ -1,201 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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");
-    });
-});