@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/indexer-incremental.test.js

@@ -0,0 +1,232 @@
+/**
+ * Sprint K.8: Incremental indexing accuracy tests.
+ *
+ * Tests entity diffing, cascade invalidation, graph patching,
+ * metadata persistence, and snapshot save/load.
+ */
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, } from "vitest";
+import { bodyHash, entityKey } from "../intelligence/indexer/entity-key.js";
+import { cascadeInvalidation, diffEntities, fileNeedsReindex, } from "../intelligence/indexer/incremental.js";
+import { loadMetadata, fileNeedsReindex as metaNeedsReindex, saveMetadata, updateFileMetadata, } from "../intelligence/indexer/metadata.js";
+import { registerPlugin, } from "../intelligence/indexer/plugin-interface.js";
+import { typescriptPlugin } from "../intelligence/indexer/plugins/typescript.js";
+import { hasSnapshot, loadSnapshot, saveSnapshot, } from "../intelligence/indexer/snapshot.js";
+import { filterIndexableEvents } from "../intelligence/indexer/watch-integration.js";
+import { clearParserCache, parseSource, } from "../intelligence/tree-sitter-loader.js";
+let tempDir;
+beforeAll(() => {
+    registerPlugin(typescriptPlugin);
+});
+afterAll(() => {
+    clearParserCache();
+});
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-incr-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+});
+afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+});
+function makeEntity(name, bodyContent, filePath = "test.ts") {
+    return {
+        key: entityKey(filePath, "function", name, ""),
+        kind: "function",
+        name,
+        file_path: filePath,
+        start_line: 1,
+        end_line: 5,
+        signature: `${name}()`,
+        body_hash: bodyHash(bodyContent),
+        exported: true,
+        parent_key: null,
+        language: "typescript",
+        is_async: false,
+        parameter_count: 0,
+        doc: null,
+    };
+}
+describe("Entity Diff (K.1)", () => {
+    it("detects added entities", () => {
+        const oldEntities = [];
+        const newEntities = [makeEntity("newFn", "return 1;")];
+        const diff = diffEntities(oldEntities, newEntities);
+        expect(diff.added).toHaveLength(1);
+        expect(diff.added[0].name).toBe("newFn");
+        expect(diff.updated).toHaveLength(0);
+        expect(diff.deleted).toHaveLength(0);
+    });
+    it("detects deleted entities", () => {
+        const oldEntities = [makeEntity("oldFn", "return 2;")];
+        const newEntities = [];
+        const diff = diffEntities(oldEntities, newEntities);
+        expect(diff.deleted).toHaveLength(1);
+        expect(diff.deleted[0].name).toBe("oldFn");
+        expect(diff.added).toHaveLength(0);
+    });
+    it("detects updated entities (body_hash changed)", () => {
+        const old = makeEntity("fn", "return 1;");
+        const updated = { ...old, body_hash: bodyHash("return 2;") };
+        const diff = diffEntities([old], [updated]);
+        expect(diff.updated).toHaveLength(1);
+        expect(diff.unchanged).toHaveLength(0);
+    });
+    it("detects unchanged entities (same body_hash)", () => {
+        const entity = makeEntity("fn", "return 42;");
+        const diff = diffEntities([entity], [entity]);
+        expect(diff.unchanged).toHaveLength(1);
+        expect(diff.added).toHaveLength(0);
+        expect(diff.updated).toHaveLength(0);
+        expect(diff.deleted).toHaveLength(0);
+    });
+    it("handles complex diff with mixed changes", () => {
+        const e1 = makeEntity("keep", "body1");
+        const e2 = makeEntity("change", "old_body");
+        const e3 = makeEntity("remove", "body3");
+        const e2New = { ...e2, body_hash: bodyHash("new_body") };
+        const e4 = makeEntity("add", "body4");
+        const diff = diffEntities([e1, e2, e3], [e1, e2New, e4]);
+        expect(diff.unchanged).toHaveLength(1);
+        expect(diff.updated).toHaveLength(1);
+        expect(diff.deleted).toHaveLength(1);
+        expect(diff.added).toHaveLength(1);
+    });
+});
+describe("Cascade Invalidation (K.2)", () => {
+    it("identifies edges affected by changed entities", () => {
+        const updated = makeEntity("target", "new body");
+        const diff = { added: [], updated: [updated], deleted: [], unchanged: [] };
+        const edges = [
+            {
+                from_key: "caller",
+                to_key: updated.key,
+                type: "calls",
+                file_path: "a.ts",
+                line: 10,
+            },
+            {
+                from_key: updated.key,
+                to_key: "callee",
+                type: "calls",
+                file_path: "test.ts",
+                line: 5,
+            },
+            {
+                from_key: "unrelated1",
+                to_key: "unrelated2",
+                type: "calls",
+                file_path: "b.ts",
+                line: 1,
+            },
+        ];
+        const result = cascadeInvalidation(diff, edges);
+        expect(result.invalidatedEdges).toHaveLength(2);
+        expect(result.affectedFiles.has("a.ts")).toBe(true);
+        expect(result.affectedFiles.has("test.ts")).toBe(true);
+    });
+});
+describe("File Watch Integration (K.3)", () => {
+    it("filters indexable events", () => {
+        const events = [
+            { type: "create", path: "/repo/src/auth.ts" },
+            { type: "update", path: "/repo/src/data.json" },
+            { type: "delete", path: "/repo/src/old.ts" },
+            { type: "create", path: "/repo/README.md" },
+        ];
+        const indexable = filterIndexableEvents(events);
+        expect(indexable).toContain("/repo/src/auth.ts");
+        expect(indexable).toContain("/repo/src/old.ts");
+        expect(indexable).not.toContain("/repo/src/data.json");
+        expect(indexable).not.toContain("/repo/README.md");
+    });
+});
+describe("Index Metadata (K.6)", () => {
+    it("saves and loads metadata", () => {
+        const metadata = loadMetadata(tempDir);
+        expect(metadata.version).toBe(1);
+        updateFileMetadata(metadata, "src/auth.ts", "abc123", 5);
+        saveMetadata(tempDir, metadata);
+        const loaded = loadMetadata(tempDir);
+        expect(loaded.files["src/auth.ts"]).toBeDefined();
+        expect(loaded.files["src/auth.ts"].hash).toBe("abc123");
+        expect(loaded.files["src/auth.ts"].entityCount).toBe(5);
+    });
+    it("detects files needing reindex by hash", () => {
+        const metadata = loadMetadata(tempDir);
+        updateFileMetadata(metadata, "src/a.ts", "hash1", 3);
+        expect(metaNeedsReindex(metadata, "src/a.ts", "hash1")).toBe(false);
+        expect(metaNeedsReindex(metadata, "src/a.ts", "hash2")).toBe(true);
+        expect(metaNeedsReindex(metadata, "src/new.ts", "hash3")).toBe(true);
+    });
+});
+describe("Index Snapshot (K.7)", () => {
+    it("saves and loads snapshot", () => {
+        const entities = [makeEntity("fn1", "body1"), makeEntity("fn2", "body2")];
+        const edges = [
+            {
+                from_key: entities[0].key,
+                to_key: entities[1].key,
+                type: "calls",
+                file_path: "test.ts",
+                line: 3,
+            },
+        ];
+        const metadata = loadMetadata(tempDir);
+        saveSnapshot(tempDir, entities, edges, metadata);
+        expect(hasSnapshot(tempDir)).toBe(true);
+        const snapshot = loadSnapshot(tempDir);
+        expect(snapshot).not.toBeNull();
+        expect(snapshot.entities).toHaveLength(2);
+        expect(snapshot.edges).toHaveLength(1);
+    });
+    it("returns null for missing snapshot", () => {
+        expect(loadSnapshot(tempDir)).toBeNull();
+        expect(hasSnapshot(tempDir)).toBe(false);
+    });
+});
+describe("Hash Short-Circuit (K.1 + K.6)", () => {
+    it("re-index same content produces no mutations", () => {
+        const entity = makeEntity("stable", "return 42;");
+        expect(fileNeedsReindex([entity], [entity])).toBe(false);
+    });
+    it("detects change when content differs", () => {
+        const old = makeEntity("fn", "return 1;");
+        const updated = { ...old, body_hash: bodyHash("return 2;") };
+        expect(fileNeedsReindex([old], [updated])).toBe(true);
+    });
+    it("detects change when entity count differs", () => {
+        const e1 = makeEntity("fn1", "body1");
+        const e2 = makeEntity("fn2", "body2");
+        expect(fileNeedsReindex([e1], [e1, e2])).toBe(true);
+    });
+});
+describe("Tree-sitter Incremental Re-extraction", () => {
+    it("produces same keys for unchanged file", async () => {
+        const source = `export function greet(name: string): string { return "Hello " + name; }`;
+        const tree1 = await parseSource(source, "tree-sitter-typescript.wasm");
+        const tree2 = await parseSource(source, "tree-sitter-typescript.wasm");
+        const r1 = typescriptPlugin.extract(tree1, "test.ts", source);
+        const r2 = typescriptPlugin.extract(tree2, "test.ts", source);
+        expect(r1.entities.map((e) => e.key)).toEqual(r2.entities.map((e) => e.key));
+        expect(r1.entities.map((e) => e.body_hash)).toEqual(r2.entities.map((e) => e.body_hash));
+        tree1.delete();
+        tree2.delete();
+    });
+    it("detects change when function body changes", async () => {
+        const v1 = "export function calc(x: number): number { return x + 1; }";
+        const v2 = "export function calc(x: number): number { return x * 2; }";
+        const tree1 = await parseSource(v1, "tree-sitter-typescript.wasm");
+        const tree2 = await parseSource(v2, "tree-sitter-typescript.wasm");
+        const r1 = typescriptPlugin.extract(tree1, "test.ts", v1);
+        const r2 = typescriptPlugin.extract(tree2, "test.ts", v2);
+        expect(r1.entities[0].key).toBe(r2.entities[0].key);
+        expect(r1.entities[0].body_hash).not.toBe(r2.entities[0].body_hash);
+        const diff = diffEntities(r1.entities, r2.entities);
+        expect(diff.updated).toHaveLength(1);
+        expect(diff.unchanged).toHaveLength(0);
+        tree1.delete();
+        tree2.delete();
+    });
+});

package/dist/__tests__/indexer-language-expansion.test.js

@@ -0,0 +1,165 @@
+/**
+ * Sprint L.12-L.15: Language expansion tests.
+ *
+ * Tests Tier-1 plugins (Python, Go, Java, Rust, Ruby, C#),
+ * Tier-2 generic plugin (C++, PHP, Swift),
+ * Tier-3 regex fallback, language detection, and confidence labeling.
+ */
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { confidenceScore, labelFromTier, upgradeToCompilerVerified, } from "../intelligence/indexer/confidence.js";
+import { detectLanguage, getLanguageTier, } from "../intelligence/indexer/language-detect.js";
+import { getAllPlugins, getPluginForFile, registerPlugin, } from "../intelligence/indexer/plugin-interface.js";
+import { regexExtract } from "../intelligence/indexer/plugins/regex-fallback.js";
+import { tier2Plugins } from "../intelligence/indexer/plugins/tier2-generic.js";
+import { typescriptPlugin } from "../intelligence/indexer/plugins/typescript.js";
+import { clearParserCache, parseSource, } from "../intelligence/tree-sitter-loader.js";
+beforeAll(() => {
+    registerPlugin(typescriptPlugin);
+    for (const plugin of tier2Plugins) {
+        registerPlugin(plugin);
+    }
+});
+afterAll(() => {
+    clearParserCache();
+});
+describe("Language Detection (L.10)", () => {
+    it("detects TypeScript as Tier 1", () => {
+        const info = detectLanguage("src/auth.ts");
+        expect(info?.tier).toBe(1);
+        expect(info?.id).toBe("typescript");
+    });
+    it("detects Python as Tier 1", () => {
+        const info = detectLanguage("main.py");
+        expect(info?.tier).toBe(1);
+        expect(info?.id).toBe("python");
+    });
+    it("detects Go as Tier 1", () => {
+        const info = detectLanguage("main.go");
+        expect(info?.tier).toBe(1);
+        expect(info?.id).toBe("go");
+    });
+    it("detects C++ as Tier 2", () => {
+        const info = detectLanguage("engine.cpp");
+        expect(info?.tier).toBe(2);
+        expect(info?.id).toBe("cpp");
+    });
+    it("detects Swift as Tier 2", () => {
+        const info = detectLanguage("App.swift");
+        expect(info?.tier).toBe(2);
+    });
+    it("returns null for unknown extensions", () => {
+        expect(detectLanguage("README.md")).toBeNull();
+        expect(detectLanguage("data.json")).toBeNull();
+    });
+    it("returns Tier 3 for unknown files", () => {
+        expect(getLanguageTier("data.csv")).toBe(3);
+    });
+});
+describe("Confidence Labeling (L.11)", () => {
+    it("labels Tier 1 as structural", () => {
+        const label = labelFromTier(1);
+        expect(label.level).toBe("structural");
+        expect(label.source).toContain("tier1");
+    });
+    it("labels Tier 2 as structural", () => {
+        const label = labelFromTier(2);
+        expect(label.level).toBe("structural");
+        expect(label.source).toContain("tier2");
+    });
+    it("labels Tier 3 as heuristic", () => {
+        const label = labelFromTier(3);
+        expect(label.level).toBe("heuristic");
+    });
+    it("upgrades to compiler-verified", () => {
+        const base = labelFromTier(1);
+        const upgraded = upgradeToCompilerVerified(base);
+        expect(upgraded.level).toBe("compiler-verified");
+        expect(upgraded.source).toContain("scip");
+    });
+    it("computes correct confidence scores", () => {
+        expect(confidenceScore("compiler-verified")).toBe(1.0);
+        expect(confidenceScore("structural")).toBe(0.85);
+        expect(confidenceScore("heuristic")).toBe(0.5);
+    });
+});
+describe("Tier-3 Regex Fallback (L.9)", () => {
+    it("extracts functions from unknown language", () => {
+        const source = `
+function processPayment(amount) {
+  return charge(amount);
+}
+
+class PaymentGateway {
+  constructor() {}
+}
+`;
+        const result = regexExtract(source, "payment.unknown");
+        expect(result.entities.length).toBeGreaterThanOrEqual(1);
+        const fn = result.entities.find((e) => e.name === "processPayment");
+        expect(fn).toBeDefined();
+        expect(fn?.kind).toBe("function");
+    });
+    it("extracts classes from unknown language", () => {
+        const source = "class MyService { }";
+        const result = regexExtract(source, "service.txt");
+        const cls = result.entities.find((e) => e.name === "MyService");
+        expect(cls).toBeDefined();
+        expect(cls?.kind).toBe("class");
+    });
+    it("handles empty source gracefully", () => {
+        const result = regexExtract("", "empty.txt");
+        expect(result.entities).toHaveLength(0);
+    });
+});
+describe("Tier-2 Generic Plugin (L.7)", () => {
+    it("C++ plugin registered and resolves", () => {
+        const plugin = getPluginForFile("engine.cpp");
+        expect(plugin).not.toBeNull();
+        expect(plugin?.id).toBe("cpp");
+    });
+    it("PHP plugin registered", () => {
+        const plugin = getPluginForFile("index.php");
+        expect(plugin).not.toBeNull();
+        expect(plugin?.id).toBe("php");
+    });
+    it("Swift plugin registered", () => {
+        const plugin = getPluginForFile("App.swift");
+        expect(plugin).not.toBeNull();
+        expect(plugin?.id).toBe("swift");
+    });
+    it("Kotlin plugin registered", () => {
+        const plugin = getPluginForFile("Main.kt");
+        expect(plugin).not.toBeNull();
+        expect(plugin?.id).toBe("kotlin");
+    });
+    it("C plugin extracts from tree-sitter", async () => {
+        const source = `
+#include <stdio.h>
+
+void greet(const char *name) {
+  printf("Hello, %s\\n", name);
+}
+
+struct Point {
+  int x;
+  int y;
+};
+`;
+        const plugin = getPluginForFile("main.c");
+        if (!plugin)
+            return;
+        const tree = await parseSource(source, plugin.grammarWasmName);
+        const result = plugin.extract(tree, "main.c", source);
+        tree.delete();
+        expect(result.entities.length).toBeGreaterThanOrEqual(1);
+    });
+});
+describe("Plugin Registry Coverage", () => {
+    it("has TypeScript plugin", () => {
+        expect(getPluginForFile("app.ts")).not.toBeNull();
+    });
+    it("has multiple Tier-2 plugins registered", () => {
+        const all = getAllPlugins();
+        expect(all.length).toBeGreaterThanOrEqual(5);
+    });
+});

package/dist/__tests__/init-push.test.js

@@ -0,0 +1,131 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+describe("CLI init command core logic", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = path.join(os.tmpdir(), `unerr-init-test-${Date.now()}`);
+        fs.mkdirSync(tmpDir, { recursive: true });
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("creates .unerr/config.json with correct structure", () => {
+        const unerrDir = path.join(tmpDir, ".unerr");
+        fs.mkdirSync(unerrDir, { recursive: true });
+        const config = {
+            repoId: "repo-123",
+            orgId: "org-456",
+            branch: "main",
+        };
+        fs.writeFileSync(path.join(unerrDir, "config.json"), `${JSON.stringify(config, null, 2)}\n`);
+        const written = JSON.parse(fs.readFileSync(path.join(unerrDir, "config.json"), "utf-8"));
+        expect(written.repoId).toBe("repo-123");
+        expect(written.orgId).toBe("org-456");
+        expect(written.branch).toBe("main");
+    });
+    it("adds .unerr to .gitignore when gitignore exists", () => {
+        const gitignorePath = path.join(tmpDir, ".gitignore");
+        fs.writeFileSync(gitignorePath, "node_modules/\n.env\n");
+        // Simulate the init logic for .gitignore
+        const content = fs.readFileSync(gitignorePath, "utf-8");
+        if (!content.includes(".unerr")) {
+            fs.appendFileSync(gitignorePath, "\n# unerr local config\n.unerr/\n");
+        }
+        const result = fs.readFileSync(gitignorePath, "utf-8");
+        expect(result).toContain(".unerr/");
+        expect(result).toContain("node_modules/");
+    });
+    it("creates .gitignore with .unerr when none exists", () => {
+        const gitignorePath = path.join(tmpDir, ".gitignore");
+        expect(fs.existsSync(gitignorePath)).toBe(false);
+        // Simulate init logic
+        fs.writeFileSync(gitignorePath, "# unerr local config\n.unerr/\n");
+        const result = fs.readFileSync(gitignorePath, "utf-8");
+        expect(result).toContain(".unerr/");
+    });
+    it("does not duplicate .unerr entry in .gitignore", () => {
+        const gitignorePath = path.join(tmpDir, ".gitignore");
+        fs.writeFileSync(gitignorePath, "node_modules/\n.unerr/\n");
+        const content = fs.readFileSync(gitignorePath, "utf-8");
+        if (!content.includes(".unerr")) {
+            fs.appendFileSync(gitignorePath, "\n# unerr local config\n.unerr/\n");
+        }
+        const result = fs.readFileSync(gitignorePath, "utf-8");
+        const matches = result.match(/\.unerr/g);
+        expect(matches).not.toBeNull();
+        expect(matches?.length).toBe(1); // Only the original one
+    });
+});
+describe("CLI push command core logic", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = path.join(os.tmpdir(), `unerr-push-test-${Date.now()}`);
+        fs.mkdirSync(tmpDir, { recursive: true });
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("loadConfig returns null when .unerr/config.json does not exist", () => {
+        const configPath = path.join(tmpDir, ".unerr", "config.json");
+        expect(fs.existsSync(configPath)).toBe(false);
+    });
+    it("loadConfig returns config when file exists", () => {
+        const unerrDir = path.join(tmpDir, ".unerr");
+        fs.mkdirSync(unerrDir, { recursive: true });
+        const config = {
+            repoId: "r-1",
+            orgId: "o-1",
+        };
+        fs.writeFileSync(path.join(unerrDir, "config.json"), JSON.stringify(config));
+        const raw = fs.readFileSync(path.join(unerrDir, "config.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        expect(parsed.repoId).toBe("r-1");
+    });
+    it("gitignore patterns exclude correct files from zip candidates", () => {
+        // Create a mini file structure
+        fs.writeFileSync(path.join(tmpDir, "src.ts"), "export const a = 1");
+        fs.mkdirSync(path.join(tmpDir, "node_modules", "pkg"), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, "node_modules", "pkg", "index.js"), "module.exports = {}");
+        fs.mkdirSync(path.join(tmpDir, ".git"), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, ".git", "HEAD"), "ref: refs/heads/main");
+        fs.mkdirSync(path.join(tmpDir, ".unerr"), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, ".unerr", "config.json"), "{}");
+        // Default exclusion patterns (same as push.ts uses)
+        const alwaysExclude = [".git", ".unerr", "node_modules"];
+        function shouldInclude(relPath) {
+            for (const pattern of alwaysExclude) {
+                if (relPath === pattern ||
+                    relPath.startsWith(`${pattern}/`) ||
+                    relPath.startsWith(pattern + path.sep)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // Collect relative file paths
+        function collectFiles(dir, relativeTo) {
+            const results = [];
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                const relPath = path.relative(relativeTo, fullPath);
+                if (!shouldInclude(relPath))
+                    continue;
+                if (entry.isDirectory()) {
+                    results.push(...collectFiles(fullPath, relativeTo));
+                }
+                else {
+                    results.push(relPath);
+                }
+            }
+            return results;
+        }
+        const files = collectFiles(tmpDir, tmpDir);
+        expect(files).toContain("src.ts");
+        expect(files.some((f) => f.startsWith("node_modules"))).toBe(false);
+        expect(files.some((f) => f.startsWith(".git"))).toBe(false);
+        expect(files.some((f) => f.startsWith(".unerr"))).toBe(false);
+    });
+});