@unerr-ai/unerr 0.1.6 → 0.1.7

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

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

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

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