@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/intelligence/tree-sitter-loader.js

@@ -1,71 +0,0 @@
-/**
- * Tree-sitter WASM Loader — lazy initialization with grammar caching.
- *
- * Loads tree-sitter and language grammars on-demand. Caches parsers
- * per-language to avoid repeated WASM compilation.
- *
- * Performance: first load ~20ms, subsequent parses <1ms per file.
- */
-let TreeSitter = null;
-let initPromise = null;
-const parserCache = new Map();
-/**
- * Initialize the Tree-sitter runtime. Idempotent — only loads once.
- */
-export async function initTreeSitter() {
-    if (TreeSitter)
-        return TreeSitter;
-    if (initPromise)
-        return initPromise;
-    initPromise = (async () => {
-        const mod = await import("web-tree-sitter");
-        const TS = mod.default;
-        await TS.init();
-        TreeSitter = TS;
-        return TS;
-    })();
-    return initPromise;
-}
-/**
- * Resolve the path to a tree-sitter WASM grammar file.
- */
-function resolveGrammarPath(wasmName) {
-    try {
-        return require.resolve(`tree-sitter-wasms/out/${wasmName}`);
-    }
-    catch {
-        const { join } = require("node:path");
-        return join(process.cwd(), "node_modules", "tree-sitter-wasms", "out", wasmName);
-    }
-}
-/**
- * Get a parser for a specific language. Caches the Language + Parser.
- */
-export async function getParser(wasmName) {
-    const cached = parserCache.get(wasmName);
-    if (cached)
-        return cached;
-    const TS = await initTreeSitter();
-    const grammarPath = resolveGrammarPath(wasmName);
-    const language = await TS.Language.load(grammarPath);
-    const parser = new TS();
-    parser.setLanguage(language);
-    parserCache.set(wasmName, parser);
-    return parser;
-}
-/**
- * Parse source code with a cached language parser.
- */
-export async function parseSource(source, wasmName) {
-    const parser = await getParser(wasmName);
-    return parser.parse(source);
-}
-/**
- * Clear parser cache (for testing or memory reclaim).
- */
-export function clearParserCache() {
-    for (const parser of parserCache.values()) {
-        parser.delete();
-    }
-    parserCache.clear();
-}

package/dist/intelligence/worker-pool.js

@@ -1,116 +0,0 @@
-/**
- * Worker pool manager for parallel AST parsing via tinypool.
- *
- * Lazy-initializes a thread pool on first use. Falls back to sequential
- * parsing if worker threads are unavailable (e.g. restricted environments).
- */
-import { existsSync } from "node:fs";
-import { cpus } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createModuleLogger } from "../utils/logger.js";
-import { extractEntities } from "./ast-extractor.js";
-const log = createModuleLogger("worker-pool");
-let pool = null;
-let poolFailed = false;
-function resolveWorkerPath() {
-    const currentDir = dirname(fileURLToPath(import.meta.url));
-    const tsPath = join(currentDir, "ast-worker.ts");
-    const jsPath = join(currentDir, "ast-worker.js");
-    if (existsSync(jsPath) && !existsSync(tsPath)) {
-        return { filename: jsPath, execArgv: [] };
-    }
-    if (existsSync(tsPath)) {
-        return {
-            filename: tsPath,
-            execArgv: ["--experimental-strip-types", "--no-warnings"],
-        };
-    }
-    return null;
-}
-async function getPool(options) {
-    if (poolFailed)
-        return null;
-    if (pool)
-        return pool;
-    const worker = resolveWorkerPath();
-    if (!worker) {
-        log.debug("Worker file not found, using sequential parsing");
-        poolFailed = true;
-        return null;
-    }
-    try {
-        const { default: Tinypool } = await import("tinypool");
-        const coreCount = cpus().length;
-        pool = new Tinypool({
-            filename: worker.filename,
-            maxThreads: options?.maxThreads ?? Math.max(1, coreCount - 1),
-            minThreads: options?.minThreads ?? 1,
-            execArgv: worker.execArgv,
-        });
-        return pool;
-    }
-    catch (err) {
-        log.warn("Worker threads unavailable, falling back to sequential parsing", err);
-        poolFailed = true;
-        return null;
-    }
-}
-function parseSequential(files) {
-    return files.map(({ filePath, content }) => {
-        const start = performance.now();
-        let entities;
-        try {
-            entities = extractEntities(content, filePath);
-        }
-        catch {
-            entities = [];
-        }
-        return {
-            filePath,
-            entities,
-            durationMs: performance.now() - start,
-        };
-    });
-}
-export async function parseFiles(files, options) {
-    if (files.length === 0)
-        return [];
-    const workerPool = await getPool(options);
-    if (!workerPool) {
-        return parseSequential(files);
-    }
-    const results = await Promise.all(files.map(async ({ filePath, content }) => {
-        const start = performance.now();
-        try {
-            const entities = await workerPool.run({
-                filePath,
-                content,
-            });
-            return {
-                filePath,
-                entities,
-                durationMs: performance.now() - start,
-            };
-        }
-        catch (err) {
-            log.debug("Worker error for %s: %s", filePath, err);
-            return {
-                filePath,
-                entities: [],
-                durationMs: performance.now() - start,
-            };
-        }
-    }));
-    return results;
-}
-export async function destroy() {
-    if (pool) {
-        await pool.destroy();
-        pool = null;
-    }
-}
-export function resetPoolState() {
-    pool = null;
-    poolFailed = false;
-}

package/dist/proxy/arg-validator.js

@@ -1,79 +0,0 @@
-/** Map from canonical schema key → accepted aliases. */
-const ALIAS_MAP = {
-    key: ["entity_name", "entity"],
-    file_path: ["file", "path"],
-};
-/**
- * Rewrite alias args onto their canonical name. Mutates `args` in place
- * (the dispatch loop owns this object). Aliases only apply when the
- * canonical key isn't already set AND the tool's schema actually declares
- * the canonical property — so we never invent fields on tools that don't
- * accept them.
- */
-export function normalizeArgAliases(toolDef, args) {
-    const props = toolDef.inputSchema.properties;
-    for (const [canonical, aliases] of Object.entries(ALIAS_MAP)) {
-        if (!(canonical in props))
-            continue;
-        if (args[canonical] !== undefined &&
-            args[canonical] !== null &&
-            args[canonical] !== "") {
-            continue;
-        }
-        for (const alias of aliases) {
-            const v = args[alias];
-            if (typeof v === "string" && v.trim() !== "") {
-                args[canonical] = v;
-                break;
-            }
-            if (typeof v === "number" || typeof v === "boolean") {
-                args[canonical] = v;
-                break;
-            }
-        }
-    }
-}
-/**
- * Check that every `required` field on the tool's schema is present and
- * non-empty in `args`. Returns null on success, or a structured failure
- * the dispatch loop can serialize back to the caller.
- *
- * Empty-string and whitespace-only values count as missing — this is the
- * Datalog-filter-mismatch failure mode that motivated the validator in
- * the first place (`recall_facts({scope:""}) → 0 rows silently`).
- */
-export function validateRequiredArgs(toolDef, args) {
-    const required = toolDef.inputSchema.required ?? [];
-    if (required.length === 0)
-        return null;
-    const missing = required.filter((field) => {
-        const v = args[field];
-        if (v === undefined || v === null)
-            return true;
-        if (typeof v === "string" && v.trim() === "")
-            return true;
-        return false;
-    });
-    if (missing.length === 0)
-        return null;
-    const props = toolDef.inputSchema.properties;
-    const details = missing
-        .map((m) => {
-        const desc = props[m]?.description?.trim();
-        return desc ? `${m}: ${desc}` : `${m}: required`;
-    })
-        .join("; ");
-    return {
-        error: `${toolDef.name}: missing required parameter(s): ${missing.join(", ")}`,
-        required: missing,
-        details,
-    };
-}
-/**
- * Convenience: normalize aliases then validate in one call. Use this in
- * the MCP dispatch loop right after destructuring the request.
- */
-export function aliasAndValidate(toolDef, args) {
-    normalizeArgAliases(toolDef, args);
-    return validateRequiredArgs(toolDef, args);
-}

package/dist/proxy/auto-bootstrap.js

@@ -1,167 +0,0 @@
-/**
- * PARSE Mode — regex-based entity extraction for degraded operation.
- *
- * Used when no CozoDB graph is available (no cozo-node binary).
- * Provides basic entity query methods that mirror the CozoGraphStore interface.
- */
-/**
- * Extract entities from a source file using regex patterns.
- * Intentionally simple — no tree-sitter dependency for PARSE mode.
- */
-export function extractEntitiesFromSource(filePath, content) {
-    const entities = [];
-    const lines = content.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? "";
-        const lineNum = i + 1;
-        // Export function / async function
-        const funcMatch = line.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*(\([^)]*\))/);
-        if (funcMatch) {
-            const name = funcMatch[1] ?? "";
-            const params = funcMatch[2] ?? "";
-            entities.push({
-                key: `${filePath}::${name}`,
-                name,
-                kind: "function",
-                file_path: filePath,
-                line_start: lineNum,
-                signature: `${name}${params}`,
-            });
-            continue;
-        }
-        // Arrow function: export const name = (...) =>
-        const arrowMatch = line.match(/^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*\w[^=]*)?\s*=>/);
-        if (arrowMatch) {
-            const name = arrowMatch[1] ?? "";
-            const params = arrowMatch[2] ?? "";
-            entities.push({
-                key: `${filePath}::${name}`,
-                name,
-                kind: "function",
-                file_path: filePath,
-                line_start: lineNum,
-                signature: `${name}(${params})`,
-            });
-            continue;
-        }
-        // Class declaration
-        const classMatch = line.match(/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/);
-        if (classMatch) {
-            const name = classMatch[1] ?? "";
-            entities.push({
-                key: `${filePath}::${name}`,
-                name,
-                kind: "class",
-                file_path: filePath,
-                line_start: lineNum,
-                signature: name,
-            });
-            continue;
-        }
-        // Interface declaration
-        const ifaceMatch = line.match(/^(?:export\s+)?interface\s+(\w+)/);
-        if (ifaceMatch) {
-            const name = ifaceMatch[1] ?? "";
-            entities.push({
-                key: `${filePath}::${name}`,
-                name,
-                kind: "interface",
-                file_path: filePath,
-                line_start: lineNum,
-                signature: name,
-            });
-            continue;
-        }
-        // Type alias
-        const typeMatch = line.match(/^(?:export\s+)?type\s+(\w+)\s*=/);
-        if (typeMatch) {
-            const name = typeMatch[1] ?? "";
-            entities.push({
-                key: `${filePath}::${name}`,
-                name,
-                kind: "type",
-                file_path: filePath,
-                line_start: lineNum,
-                signature: name,
-            });
-            continue;
-        }
-        // Method declarations inside classes (indented)
-        const methodMatch = line.match(/^\s+(?:async\s+)?(?:static\s+)?(?:private\s+|protected\s+|public\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*\S+)?\s*\{/);
-        if (methodMatch &&
-            methodMatch[1] !== "if" &&
-            methodMatch[1] !== "for" &&
-            methodMatch[1] !== "while" &&
-            methodMatch[1] !== "switch" &&
-            methodMatch[1] !== "catch") {
-            // Try to find the enclosing class
-            const className = findEnclosingClass(lines, i);
-            const name = methodMatch[1] ?? "";
-            entities.push({
-                key: `${filePath}::${className ? `${className}.` : ""}${name}`,
-                name: className ? `${className}.${name}` : name,
-                kind: "method",
-                file_path: filePath,
-                line_start: lineNum,
-                signature: `${name}(${methodMatch[2]})`,
-            });
-        }
-    }
-    return entities;
-}
-function findEnclosingClass(lines, currentLine) {
-    for (let i = currentLine - 1; i >= 0; i--) {
-        const match = lines[i]?.match(/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/);
-        if (match)
-            return match[1];
-    }
-    return null;
-}
-/**
- * In-memory entity index for PARSE mode.
- * Provides basic query methods that mirror the CozoGraphStore interface.
- */
-export class ParseModeIndex {
-    entities = [];
-    byKey = new Map();
-    byFile = new Map();
-    addEntities(entities) {
-        for (const e of entities) {
-            this.entities.push(e);
-            this.byKey.set(e.key, e);
-            const fileEntities = this.byFile.get(e.file_path) ?? [];
-            fileEntities.push(e);
-            this.byFile.set(e.file_path, fileEntities);
-        }
-    }
-    getEntity(key) {
-        return this.byKey.get(key) ?? null;
-    }
-    getEntitiesByFile(filePath) {
-        return this.byFile.get(filePath) ?? [];
-    }
-    search(query, limit = 20) {
-        const lower = query.toLowerCase();
-        const results = [];
-        for (const e of this.entities) {
-            if (e.name.toLowerCase().includes(lower) ||
-                e.key.toLowerCase().includes(lower)) {
-                results.push(e);
-                if (results.length >= limit)
-                    break;
-            }
-        }
-        return results;
-    }
-    getStats() {
-        return {
-            entityCount: this.entities.length,
-            fileCount: this.byFile.size,
-        };
-    }
-    clear() {
-        this.entities = [];
-        this.byKey.clear();
-        this.byFile.clear();
-    }
-}

package/dist/proxy/bridge.js

@@ -1,147 +0,0 @@
-/**
- * `unerr --mcp` bridge — thin stdio ↔ UDS relay with heartbeat.
- *
- * Sole job: forward MCP JSON-RPC frames between the IDE's stdio and the
- * per-repo `unerr` process's UDS socket. The bridge imports **no** modules
- * from `src/intelligence/` or `src/behaviors/` (Layer 12 DM-0 invariant) —
- * all graph / fact / ledger work lives in the per-repo process.
- *
- * Heartbeat:
- *   - Sends JSON-RPC `unerr/ping` every 5 s, expects `unerr/pong` within 2 s
- *   - 3 missed heartbeats → bridge resolves with reason="daemon_dead"
- *   - Caller (cli.ts mcpBoot) prints an error and exits 1; DM-3 will add
- *     auto-spawn so the user never has to start the proxy manually.
- *
- * Protocol: newline-delimited JSON-RPC over UDS (matches TransportMux).
- */
-import { connect } from "node:net";
-/** stderr-only logger. stdout is MCP territory. */
-const log = {
-    info: (msg) => process.stderr.write(`[unerr:bridge] ${msg}\n`),
-    warn: (msg) => process.stderr.write(`[unerr:bridge] WARN: ${msg}\n`),
-};
-const HEARTBEAT_INTERVAL_MS = 5_000;
-const HEARTBEAT_TIMEOUT_MS = 2_000;
-const MAX_MISSED_HEARTBEATS = 3;
-/**
- * Start bridging stdin/stdout to the proxy's UDS socket.
- * Returns when the connection closes, with a reason indicating why.
- */
-export function startUdsBridge(sockPath) {
-    return new Promise((resolve, reject) => {
-        const socket = connect(sockPath);
-        let heartbeatTimer;
-        let heartbeatTimeoutTimer;
-        let missedHeartbeats = 0;
-        let pendingPing = false;
-        let resolved = false;
-        function cleanup(reason) {
-            if (resolved)
-                return;
-            resolved = true;
-            if (heartbeatTimer)
-                clearInterval(heartbeatTimer);
-            if (heartbeatTimeoutTimer)
-                clearTimeout(heartbeatTimeoutTimer);
-            if (!socket.destroyed)
-                socket.destroy();
-            resolve({ reason });
-        }
-        socket.on("connect", () => {
-            log.info(`Connected to proxy at ${sockPath}`);
-            // stdin → UDS: forward MCP requests from IDE to proxy
-            process.stdin.on("data", (chunk) => {
-                if (!socket.destroyed) {
-                    socket.write(chunk);
-                }
-            });
-            // UDS → stdout: forward MCP responses from proxy to IDE
-            socket.on("data", (data) => {
-                // Check if this is a heartbeat pong response
-                const str = data.toString();
-                if (str.includes('"unerr/pong"')) {
-                    missedHeartbeats = 0;
-                    pendingPing = false;
-                    if (heartbeatTimeoutTimer) {
-                        clearTimeout(heartbeatTimeoutTimer);
-                        heartbeatTimeoutTimer = undefined;
-                    }
-                    // Filter out pong from data sent to IDE — find and remove the pong line
-                    const lines = str.split("\n");
-                    const filtered = lines.filter((l) => !l.includes('"unerr/pong"'));
-                    const remaining = filtered.join("\n");
-                    if (remaining.trim().length > 0) {
-                        process.stdout.write(remaining);
-                    }
-                    return;
-                }
-                process.stdout.write(data);
-            });
-            // Start heartbeat monitoring
-            heartbeatTimer = setInterval(() => {
-                if (socket.destroyed) {
-                    cleanup("daemon_dead");
-                    return;
-                }
-                if (pendingPing) {
-                    // Previous ping didn't get a pong
-                    missedHeartbeats++;
-                    if (missedHeartbeats >= MAX_MISSED_HEARTBEATS) {
-                        log.warn(`${MAX_MISSED_HEARTBEATS} heartbeats missed — daemon appears dead`);
-                        cleanup("daemon_dead");
-                        return;
-                    }
-                }
-                // Send heartbeat ping as JSON-RPC notification
-                pendingPing = true;
-                const ping = JSON.stringify({
-                    jsonrpc: "2.0",
-                    method: "unerr/ping",
-                    params: { ts: Date.now() },
-                });
-                try {
-                    socket.write(`${ping}\n`);
-                }
-                catch {
-                    cleanup("daemon_dead");
-                    return;
-                }
-                // Set timeout for this specific ping
-                heartbeatTimeoutTimer = setTimeout(() => {
-                    // Ping timed out — increment missed count (handled on next interval)
-                    heartbeatTimeoutTimer = undefined;
-                }, HEARTBEAT_TIMEOUT_MS);
-            }, HEARTBEAT_INTERVAL_MS);
-        });
-        socket.on("close", () => {
-            log.info("Proxy connection closed");
-            cleanup("socket_closed");
-        });
-        socket.on("error", (err) => {
-            log.warn(`Connection error: ${err.message}`);
-            if (resolved)
-                return;
-            // Connection errors before connect are fatal
-            if (!socket.connecting && !heartbeatTimer) {
-                reject(err);
-            }
-            else {
-                cleanup("daemon_dead");
-            }
-        });
-        // If stdin closes (IDE disconnects), allow a grace period for pending
-        // responses before tearing down. Without this, piped input like
-        //   echo '{"jsonrpc":"2.0",...}' | unerr --mcp
-        // closes stdin immediately, destroying the socket before the proxy
-        // can write its response back.
-        process.stdin.on("end", () => {
-            const grace = setTimeout(() => cleanup("stdin_closed"), 3_000);
-            socket.once("end", () => {
-                clearTimeout(grace);
-                cleanup("stdin_closed");
-            });
-        });
-        // Keep the process alive while bridging
-        process.stdin.resume();
-    });
-}

package/dist/proxy/budget-enforcer.js

@@ -1,70 +0,0 @@
-/**
- * Budget Enforcer — enforces per-response token budgets.
- *
- * Responses exceeding the budget are smart-trimmed:
- *   1. If text: truncate with "..." marker, preserving first/last segments
- *   2. Adds _meta["dev.unerr/truncated"] = true
- *   3. Adds _meta["dev.unerr/original_tokens"] with the pre-truncation count
- *
- * Only applies to text-heavy responses. Structured data (JSON objects with
- * entity keys, blast radius) passes through unchanged.
- */
-import { estimateTokenCount } from "../intelligence/token-estimator.js";
-/**
- * Enforce a token budget on text content.
- * Returns the (possibly truncated) content and metadata.
- */
-export function enforceBudget(content, budget, options = {}) {
-    const maxTokens = budget ?? options.defaultBudget ?? 4000;
-    const headRatio = options.preserveHeadRatio ?? 0.7;
-    const originalTokens = estimateTokenCount(content);
-    if (originalTokens <= maxTokens) {
-        return {
-            content,
-            truncated: false,
-            originalTokens,
-            deliveredTokens: originalTokens,
-        };
-    }
-    const lines = content.split("\n");
-    const headLines = Math.floor(lines.length * headRatio);
-    const tailLines = Math.max(3, Math.floor(lines.length * 0.1));
-    const head = lines.slice(0, headLines);
-    const tail = lines.slice(-tailLines);
-    let result = head.join("\n");
-    let tokens = estimateTokenCount(result);
-    while (tokens > maxTokens * headRatio && head.length > 10) {
-        head.pop();
-        result = head.join("\n");
-        tokens = estimateTokenCount(result);
-    }
-    const omittedCount = lines.length - head.length - tail.length;
-    const marker = `\n\n[... ${omittedCount} lines truncated (${originalTokens - tokens} tokens over budget) ...]\n\n`;
-    const tailText = tail.join("\n");
-    const truncatedContent = result + marker + tailText;
-    const deliveredTokens = estimateTokenCount(truncatedContent);
-    return {
-        content: truncatedContent,
-        truncated: true,
-        originalTokens,
-        deliveredTokens,
-    };
-}
-/**
- * Check if content is structured JSON (skip budget enforcement).
- */
-export function isStructuredContent(content) {
-    if (typeof content !== "string")
-        return true;
-    const trimmed = content.trim();
-    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-        try {
-            JSON.parse(trimmed);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    return false;
-}