@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/intelligence/indexer/graph-patch.js

@@ -1,147 +0,0 @@
-/**
- * Graph Patch Operations — surgical updates to the CozoDB graph.
- *
- * Instead of full re-ingestion, patches apply targeted:
- *   - Delete entity + all edges to/from it
- *   - Update entity in place (body_hash changed)
- *   - Insert new entities + edges
- *
- * This is the write-side of incremental indexing.
- */
-import { createModuleLogger } from "../../utils/logger.js";
-const log = createModuleLogger("graph-patch");
-/**
- * Delete an entity and all its edges from the graph.
- */
-async function deleteEntity(db, entityKey) {
-    try {
-        await db.run("?[key] <- [[$key]] :rm entities { key }", { key: entityKey });
-    }
-    catch {
-        /* entity may not exist — safe to ignore */
-    }
-    try {
-        await db.run(`?[from_key, to_key, type] := *edges{ from_key, to_key, type }, from_key = $key
-       :rm edges { from_key, to_key, type }`, { key: entityKey });
-    }
-    catch {
-        /* no outgoing edges — safe */
-    }
-    try {
-        await db.run(`?[from_key, to_key, type] := *edges{ from_key, to_key, type }, to_key = $key
-       :rm edges { from_key, to_key, type }`, { key: entityKey });
-    }
-    catch {
-        /* no incoming edges — safe */
-    }
-    try {
-        await db.run(`?[file_path, entity_key] := *file_index{ file_path, entity_key }, entity_key = $key
-       :rm file_index { file_path, entity_key }`, { key: entityKey });
-    }
-    catch {
-        /* not in file_index — safe */
-    }
-}
-/**
- * Upsert an entity into the graph.
- */
-async function upsertEntity(db, entity) {
-    try {
-        await db.run(`?[key, kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, community] <-
-         [[$key, $kind, $name, $fp, $sl, $el, $sig, $body, 0, 0, "normal", -1]]
-       :put entities { key => kind, name, file_path, start_line, end_line, signature, body, fan_in, fan_out, risk_level, community }`, {
-            key: entity.key,
-            kind: entity.kind,
-            name: entity.name,
-            fp: entity.file_path,
-            sl: entity.start_line,
-            sig: entity.signature,
-            el: entity.end_line,
-            body: entity.body_hash,
-        });
-        await db.run(`?[file_path, entity_key] <- [[$fp, $ek]]
-       :put file_index { file_path, entity_key }`, { fp: entity.file_path, ek: entity.key });
-    }
-    catch (err) {
-        log.debug(`Upsert entity failed for ${entity.key}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-/**
- * Insert edges into the graph (skipping unresolved).
- */
-async function insertEdges(db, edges) {
-    const valid = edges.filter((e) => !e.to_key.startsWith("unresolved:"));
-    if (valid.length === 0)
-        return 0;
-    let count = 0;
-    for (const edge of valid) {
-        try {
-            await db.run(`?[from_key, to_key, type] <- [[$fk, $tk, $type]]
-         :put edges { from_key, to_key, type }`, { fk: edge.from_key, tk: edge.to_key, type: edge.type });
-            count++;
-        }
-        catch {
-            /* edge may conflict — safe to skip */
-        }
-    }
-    return count;
-}
-/**
- * Apply an entity diff as graph patches.
- */
-export async function applyGraphPatch(db, diff, newEdges, oldEdgeKeys) {
-    const start = performance.now();
-    for (const entity of diff.deleted) {
-        await deleteEntity(db, entity.key);
-    }
-    for (const entity of diff.updated) {
-        await deleteEntity(db, entity.key);
-        await upsertEntity(db, entity);
-    }
-    for (const entity of diff.added) {
-        await upsertEntity(db, entity);
-    }
-    if (oldEdgeKeys) {
-        for (const edgeKey of oldEdgeKeys) {
-            const [fromKey, toKey, type] = edgeKey.split("::");
-            if (fromKey && toKey && type) {
-                try {
-                    await db.run(`?[from_key, to_key, type] <- [[$fk, $tk, $type]]
-             :rm edges { from_key, to_key, type }`, { fk: fromKey, tk: toKey, type });
-                }
-                catch {
-                    /* safe */
-                }
-            }
-        }
-    }
-    const edgesAdded = await insertEdges(db, newEdges);
-    const durationMs = performance.now() - start;
-    log.debug(`Patch: +${diff.added.length} ~${diff.updated.length} -${diff.deleted.length} entities, +${edgesAdded} edges (${Math.round(durationMs)}ms)`);
-    return {
-        entitiesDeleted: diff.deleted.length,
-        entitiesUpdated: diff.updated.length,
-        entitiesAdded: diff.added.length,
-        edgesDeleted: oldEdgeKeys?.size ?? 0,
-        edgesAdded,
-        durationMs,
-    };
-}
-/**
- * Delete all entities and edges for a specific file.
- */
-export async function deleteFileFromGraph(db, filePath) {
-    let deleted = 0;
-    try {
-        const result = await db.run("?[entity_key] := *file_index{ file_path: $fp, entity_key }", { fp: filePath });
-        const keys = result.rows.map((r) => r[0]);
-        for (const key of keys) {
-            await deleteEntity(db, key);
-            deleted++;
-        }
-    }
-    catch {
-        /* file not in index — safe */
-    }
-    return deleted;
-}

package/dist/intelligence/indexer/incremental.js

@@ -1,78 +0,0 @@
-/**
- * Incremental Indexing — entity diff + cascade invalidation.
- *
- * K.1: Compares old vs new entities for a file. Produces added/updated/deleted sets.
- *       Uses body_hash for efficient change detection (no content comparison needed).
- *
- * K.2: When an entity changes, identifies all edges that reference it
- *       (both incoming and outgoing) for invalidation and re-resolution.
- */
-/**
- * Diff old vs new entities for a single file.
- * Matches by key (deterministic). Detects changes via body_hash.
- */
-export function diffEntities(oldEntities, newEntities) {
-    const oldMap = new Map(oldEntities.map((e) => [e.key, e]));
-    const newMap = new Map(newEntities.map((e) => [e.key, e]));
-    const added = [];
-    const updated = [];
-    const unchanged = [];
-    const deleted = [];
-    for (const [key, newEntity] of newMap) {
-        const oldEntity = oldMap.get(key);
-        if (!oldEntity) {
-            added.push(newEntity);
-        }
-        else if (oldEntity.body_hash !== newEntity.body_hash) {
-            updated.push(newEntity);
-        }
-        else {
-            unchanged.push(newEntity);
-        }
-    }
-    for (const [key, oldEntity] of oldMap) {
-        if (!newMap.has(key)) {
-            deleted.push(oldEntity);
-        }
-    }
-    return { added, updated, deleted, unchanged };
-}
-/**
- * Determine which edges are invalidated by entity changes.
- * An edge is invalidated if either its from_key or to_key was added, updated, or deleted.
- */
-export function cascadeInvalidation(diff, allEdges) {
-    const changedKeys = new Set();
-    for (const e of diff.added)
-        changedKeys.add(e.key);
-    for (const e of diff.updated)
-        changedKeys.add(e.key);
-    for (const e of diff.deleted)
-        changedKeys.add(e.key);
-    const invalidatedEdges = [];
-    const affectedFiles = new Set();
-    const affectedEntityKeys = new Set();
-    for (const edge of allEdges) {
-        if (changedKeys.has(edge.from_key) || changedKeys.has(edge.to_key)) {
-            invalidatedEdges.push(edge);
-            affectedFiles.add(edge.file_path);
-            affectedEntityKeys.add(edge.from_key);
-            affectedEntityKeys.add(edge.to_key);
-        }
-    }
-    return { invalidatedEdges, affectedFiles, affectedEntityKeys };
-}
-/**
- * Check if a file needs re-indexing by comparing entity hashes.
- * Returns true if any entity has changed (fast short-circuit).
- */
-export function fileNeedsReindex(oldEntities, newEntities) {
-    if (oldEntities.length !== newEntities.length)
-        return true;
-    const oldHashes = new Set(oldEntities.map((e) => `${e.key}:${e.body_hash}`));
-    for (const e of newEntities) {
-        if (!oldHashes.has(`${e.key}:${e.body_hash}`))
-            return true;
-    }
-    return false;
-}

package/dist/intelligence/indexer/ingest.js

@@ -1,160 +0,0 @@
-/**
- * CozoDB Bulk Ingestion — batch inserts entities + edges into the graph store.
- *
- * Designed for initial indexing and full re-index scenarios.
- * Uses CozoDB's `:put` (upsert) to handle re-indexing gracefully.
- * Batch size is configurable to respect memory limits.
- *
- * File-as-L0: Every file gets a `file:<path>` entity (kind="module") and every
- * entity gets a `contains` edge from its parent file entity. This guarantees
- * zero orphans in the graph — every entity is reachable via its file node.
- */
-import { basename } from "node:path";
-import { createModuleLogger } from "../../utils/logger.js";
-import { isTestFile } from "./test-detector.js";
-const log = createModuleLogger("ingest");
-const ENTITY_BATCH_SIZE = 500;
-const EDGE_BATCH_SIZE = 1000;
-/**
- * Collect unique file paths and create file-level entities.
- * Each file gets a `file:<path>` entity with kind="module".
- */
-function ingestFileEntities(db, entities) {
-    const filePaths = new Set();
-    for (const e of entities) {
-        if (e.file_path)
-            filePaths.add(e.file_path);
-    }
-    if (filePaths.size === 0)
-        return 0;
-    const rows = Array.from(filePaths, (fp) => [
-        `file:${fp}`,
-        "module",
-        basename(fp),
-        fp,
-        0,
-        "",
-        "",
-        0,
-        0,
-        "normal",
-        -1,
-    ]);
-    let ingested = 0;
-    for (let i = 0; i < rows.length; i += ENTITY_BATCH_SIZE) {
-        const batch = rows.slice(i, i + ENTITY_BATCH_SIZE);
-        try {
-            db.run(`?[key, kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, community] <- $rows
-         :put entities { key => kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, community }`, { rows: batch });
-            ingested += batch.length;
-        }
-        catch (err) {
-            log.warn(`File entity batch failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return ingested;
-}
-/**
- * Create `contains` edges from file entities to their child entities.
- * This guarantees every entity is reachable via its parent file node.
- */
-function ingestContainsEdges(db, entities) {
-    const rows = entities
-        .filter((e) => e.file_path)
-        .map((e) => [`file:${e.file_path}`, e.key, "contains"]);
-    let ingested = 0;
-    for (let i = 0; i < rows.length; i += EDGE_BATCH_SIZE) {
-        const batch = rows.slice(i, i + EDGE_BATCH_SIZE);
-        try {
-            db.run(`?[from_key, to_key, type] <- $rows
-         :put edges { from_key, to_key, type }`, { rows: batch });
-            ingested += batch.length;
-        }
-        catch (err) {
-            log.warn(`Contains edge batch failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return ingested;
-}
-/**
- * Bulk ingest entities into CozoDB.
- * Also populates file_index for fast file→entity lookups.
- */
-function ingestEntities(db, entities) {
-    let ingested = 0;
-    for (let i = 0; i < entities.length; i += ENTITY_BATCH_SIZE) {
-        const batch = entities.slice(i, i + ENTITY_BATCH_SIZE);
-        const rows = batch.map((e) => [
-            e.key,
-            e.kind,
-            e.name,
-            e.file_path,
-            e.start_line,
-            e.signature,
-            e.body_hash,
-            0,
-            0,
-            "normal",
-            -1,
-            e.is_test ?? isTestFile(e.file_path),
-        ]);
-        try {
-            db.run(`?[key, kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, community, is_test] <- $rows
-         :put entities { key => kind, name, file_path, start_line, signature, body, fan_in, fan_out, risk_level, community, is_test }`, { rows });
-            const fileIndexRows = batch.map((e) => [e.file_path, e.key]);
-            db.run(`?[file_path, entity_key] <- $rows
-         :put file_index { file_path, entity_key }`, { rows: fileIndexRows });
-            ingested += batch.length;
-        }
-        catch (err) {
-            log.warn(`Entity batch ingest failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return ingested;
-}
-/**
- * Bulk ingest edges into CozoDB.
- */
-function ingestEdges(db, edges) {
-    let ingested = 0;
-    const validEdges = edges.filter((e) => !e.to_key.startsWith("unresolved:"));
-    for (let i = 0; i < validEdges.length; i += EDGE_BATCH_SIZE) {
-        const batch = validEdges.slice(i, i + EDGE_BATCH_SIZE);
-        const rows = batch.map((e) => [e.from_key, e.to_key, e.type]);
-        try {
-            db.run(`?[from_key, to_key, type] <- $rows
-         :put edges { from_key, to_key, type }`, { rows });
-            ingested += batch.length;
-        }
-        catch (err) {
-            log.warn(`Edge batch ingest failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return ingested;
-}
-/**
- * Ingest a full index result into CozoDB.
- *
- * Order: file entities → code entities → contains edges → code edges.
- * File entities must exist before contains edges reference them.
- */
-export function ingestIndexResult(db, entities, edges) {
-    const start = performance.now();
-    // R.1: Create file-level entities (file:<path> with kind="module")
-    const fileEntities = ingestFileEntities(db, entities);
-    // Ingest code-level entities
-    const entitiesIngested = ingestEntities(db, entities);
-    // R.2: Create contains edges (file → entity)
-    const containsEdges = ingestContainsEdges(db, entities);
-    // Ingest code-level edges (calls, imports, extends, etc.)
-    const edgesIngested = ingestEdges(db, edges);
-    const durationMs = performance.now() - start;
-    log.info(`Ingested ${fileEntities} files + ${entitiesIngested} entities + ${containsEdges + edgesIngested} edges in ${Math.round(durationMs)}ms`);
-    return {
-        entitiesIngested,
-        edgesIngested,
-        fileEntities,
-        containsEdges,
-        durationMs,
-    };
-}

package/dist/intelligence/indexer/language-detect.js

@@ -1,226 +0,0 @@
-/**
- * Language Detection & Tier Assignment — maps file extensions to languages,
- * assigns extraction tiers, and dispatches to the correct plugin.
- *
- * Tiers:
- *   Tier 1: Full tree-sitter + SCIP enrichment path (8 languages)
- *   Tier 2: Tree-sitter extraction only (10+ languages)
- *   Tier 3: Regex fallback for unknown languages
- */
-const LANGUAGE_MAP = {
-    ".ts": {
-        id: "typescript",
-        name: "TypeScript",
-        tier: 1,
-        extensions: [".ts", ".tsx"],
-        grammarWasm: "tree-sitter-typescript.wasm",
-    },
-    ".tsx": {
-        id: "typescript",
-        name: "TypeScript",
-        tier: 1,
-        extensions: [".ts", ".tsx"],
-        grammarWasm: "tree-sitter-typescript.wasm",
-    },
-    ".js": {
-        id: "javascript",
-        name: "JavaScript",
-        tier: 1,
-        extensions: [".js", ".jsx", ".mjs", ".cjs"],
-        grammarWasm: "tree-sitter-javascript.wasm",
-    },
-    ".jsx": {
-        id: "javascript",
-        name: "JavaScript",
-        tier: 1,
-        extensions: [".js", ".jsx", ".mjs", ".cjs"],
-        grammarWasm: "tree-sitter-javascript.wasm",
-    },
-    ".mjs": {
-        id: "javascript",
-        name: "JavaScript",
-        tier: 1,
-        extensions: [".js", ".jsx", ".mjs", ".cjs"],
-        grammarWasm: "tree-sitter-javascript.wasm",
-    },
-    ".cjs": {
-        id: "javascript",
-        name: "JavaScript",
-        tier: 1,
-        extensions: [".js", ".jsx", ".mjs", ".cjs"],
-        grammarWasm: "tree-sitter-javascript.wasm",
-    },
-    ".py": {
-        id: "python",
-        name: "Python",
-        tier: 1,
-        extensions: [".py"],
-        grammarWasm: "tree-sitter-python.wasm",
-    },
-    ".go": {
-        id: "go",
-        name: "Go",
-        tier: 1,
-        extensions: [".go"],
-        grammarWasm: "tree-sitter-go.wasm",
-    },
-    ".java": {
-        id: "java",
-        name: "Java",
-        tier: 1,
-        extensions: [".java"],
-        grammarWasm: "tree-sitter-java.wasm",
-    },
-    ".rs": {
-        id: "rust",
-        name: "Rust",
-        tier: 1,
-        extensions: [".rs"],
-        grammarWasm: "tree-sitter-rust.wasm",
-    },
-    ".rb": {
-        id: "ruby",
-        name: "Ruby",
-        tier: 1,
-        extensions: [".rb"],
-        grammarWasm: "tree-sitter-ruby.wasm",
-    },
-    ".cs": {
-        id: "csharp",
-        name: "C#",
-        tier: 1,
-        extensions: [".cs"],
-        grammarWasm: "tree-sitter-c_sharp.wasm",
-    },
-    ".c": {
-        id: "c",
-        name: "C",
-        tier: 2,
-        extensions: [".c", ".h"],
-        grammarWasm: "tree-sitter-c.wasm",
-    },
-    ".h": {
-        id: "c",
-        name: "C",
-        tier: 2,
-        extensions: [".c", ".h"],
-        grammarWasm: "tree-sitter-c.wasm",
-    },
-    ".cpp": {
-        id: "cpp",
-        name: "C++",
-        tier: 2,
-        extensions: [".cpp", ".cc", ".cxx", ".hpp"],
-        grammarWasm: "tree-sitter-cpp.wasm",
-    },
-    ".cc": {
-        id: "cpp",
-        name: "C++",
-        tier: 2,
-        extensions: [".cpp", ".cc", ".cxx", ".hpp"],
-        grammarWasm: "tree-sitter-cpp.wasm",
-    },
-    ".cxx": {
-        id: "cpp",
-        name: "C++",
-        tier: 2,
-        extensions: [".cpp", ".cc", ".cxx", ".hpp"],
-        grammarWasm: "tree-sitter-cpp.wasm",
-    },
-    ".hpp": {
-        id: "cpp",
-        name: "C++",
-        tier: 2,
-        extensions: [".cpp", ".cc", ".cxx", ".hpp"],
-        grammarWasm: "tree-sitter-cpp.wasm",
-    },
-    ".php": {
-        id: "php",
-        name: "PHP",
-        tier: 2,
-        extensions: [".php"],
-        grammarWasm: "tree-sitter-php.wasm",
-    },
-    ".swift": {
-        id: "swift",
-        name: "Swift",
-        tier: 2,
-        extensions: [".swift"],
-        grammarWasm: "tree-sitter-swift.wasm",
-    },
-    ".kt": {
-        id: "kotlin",
-        name: "Kotlin",
-        tier: 2,
-        extensions: [".kt", ".kts"],
-        grammarWasm: "tree-sitter-kotlin.wasm",
-    },
-    ".kts": {
-        id: "kotlin",
-        name: "Kotlin",
-        tier: 2,
-        extensions: [".kt", ".kts"],
-        grammarWasm: "tree-sitter-kotlin.wasm",
-    },
-    ".scala": {
-        id: "scala",
-        name: "Scala",
-        tier: 2,
-        extensions: [".scala"],
-        grammarWasm: "tree-sitter-scala.wasm",
-    },
-    ".lua": {
-        id: "lua",
-        name: "Lua",
-        tier: 2,
-        extensions: [".lua"],
-        grammarWasm: "tree-sitter-lua.wasm",
-    },
-    ".dart": {
-        id: "dart",
-        name: "Dart",
-        tier: 2,
-        extensions: [".dart"],
-        grammarWasm: "tree-sitter-dart.wasm",
-    },
-    ".ex": {
-        id: "elixir",
-        name: "Elixir",
-        tier: 2,
-        extensions: [".ex", ".exs"],
-        grammarWasm: "tree-sitter-elixir.wasm",
-    },
-    ".exs": {
-        id: "elixir",
-        name: "Elixir",
-        tier: 2,
-        extensions: [".ex", ".exs"],
-        grammarWasm: "tree-sitter-elixir.wasm",
-    },
-    ".zig": {
-        id: "zig",
-        name: "Zig",
-        tier: 2,
-        extensions: [".zig"],
-        grammarWasm: "tree-sitter-zig.wasm",
-    },
-};
-export function detectLanguage(filePath) {
-    const dot = filePath.lastIndexOf(".");
-    if (dot < 0)
-        return null;
-    const ext = filePath.slice(dot).toLowerCase();
-    return LANGUAGE_MAP[ext] ?? null;
-}
-export function getLanguageTier(filePath) {
-    const info = detectLanguage(filePath);
-    if (!info)
-        return 3;
-    return info.tier;
-}
-export function isSupportedExtension(ext) {
-    return ext in LANGUAGE_MAP;
-}
-export function getAllSupportedExtensions() {
-    return Object.keys(LANGUAGE_MAP);
-}

package/dist/intelligence/indexer/metadata.js

@@ -1,63 +0,0 @@
-/**
- * Index Metadata Persistence — tracks indexing state in .unerr/index/metadata.json.
- *
- * Stores: last index timestamp, file hashes, entity counts per file.
- * Used by incremental indexing to determine which files need re-processing.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-const METADATA_VERSION = 1;
-function defaultMetadata() {
-    return {
-        version: METADATA_VERSION,
-        lastFullIndex: new Date().toISOString(),
-        files: {},
-        totalEntities: 0,
-        totalEdges: 0,
-    };
-}
-export function loadMetadata(unerrDir) {
-    const indexDir = join(unerrDir, "index");
-    const metaPath = join(indexDir, "metadata.json");
-    if (!existsSync(metaPath))
-        return defaultMetadata();
-    try {
-        const raw = readFileSync(metaPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        if (parsed.version !== METADATA_VERSION)
-            return defaultMetadata();
-        return parsed;
-    }
-    catch {
-        return defaultMetadata();
-    }
-}
-export function saveMetadata(unerrDir, metadata) {
-    const indexDir = join(unerrDir, "index");
-    if (!existsSync(indexDir)) {
-        mkdirSync(indexDir, { recursive: true });
-    }
-    const metaPath = join(indexDir, "metadata.json");
-    try {
-        writeFileSync(metaPath, JSON.stringify(metadata, null, 2), "utf-8");
-    }
-    catch {
-        /* best effort */
-    }
-}
-export function updateFileMetadata(metadata, filePath, hash, entityCount) {
-    metadata.files[filePath] = {
-        hash,
-        entityCount,
-        lastIndexed: new Date().toISOString(),
-    };
-}
-export function removeFileMetadata(metadata, filePath) {
-    delete metadata.files[filePath];
-}
-export function fileNeedsReindex(metadata, filePath, currentHash) {
-    const existing = metadata.files[filePath];
-    if (!existing)
-        return true;
-    return existing.hash !== currentHash;
-}