@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/intelligence/indexer/scip/orchestrator.js

@@ -1,433 +0,0 @@
-/**
- * SCIP Inline Orchestrator — runs SCIP enrichment as part of the indexing pipeline.
- *
- * NOT a background process. Runs inline after tree-sitter extraction completes.
- * For TypeScript projects (~375 files), completes in ~5-15 seconds.
- *
- * Pipeline:
- *   1. Detect primary language from discovered files
- *   2. Resolve SCIP binary (bundled for TS, cached/PATH for others)
- *   3. If not available, auto-download from GitHub releases
- *   4. Run SCIP indexer → protobuf output
- *   5. Decode protobuf → symbol occurrences
- *   6. Merge with tree-sitter edges → compiler-verified graph
- */
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
-import { exec } from "../../../utils/exec.js";
-import { createModuleLogger } from "../../../utils/logger.js";
-import { decodeScipOutput } from "./decoder.js";
-import { detectProjectLanguages, detectScipBinary, } from "./detector.js";
-import { downloadScipBinary, getManualInstallInstructions, isAutoDownloadSupported, } from "./downloader.js";
-import { mergeScipResults, } from "./merger.js";
-import { runScipIndexer } from "./runner.js";
-const log = createModuleLogger("scip-orchestrator");
-export async function enrichWithScip(files, projectRoot, existingEdges, entities, options) {
-    // Step 1: Detect ALL languages in the project
-    const languages = detectProjectLanguages(files);
-    if (languages.length === 0) {
-        return skipResult(existingEdges, "No supported language detected");
-    }
-    let currentEdges = markAsStructural(existingEdges);
-    let lastRunResult = null;
-    let lastDecodeResult = null;
-    let lastMergeResult = null;
-    let anySucceeded = false;
-    const processedLanguages = [];
-    for (const { language, fileCount } of languages) {
-        // Step 2: Resolve SCIP binary
-        let binaryInfo = await detectScipBinary(language);
-        // Step 3: Auto-install if not available
-        if (!binaryInfo.available) {
-            if (language === "csharp") {
-                // C# uses dotnet tool install instead of binary download
-                const installed = await installScipDotnet();
-                if (installed) {
-                    binaryInfo = await detectScipBinary(language);
-                }
-                else {
-                    continue;
-                }
-            }
-            else if (isAutoDownloadSupported(language)) {
-                log.info(`SCIP binary not found for ${language}, downloading...`);
-                const downloadResult = await downloadScipBinary(language, (msg) => {
-                    log.info(msg);
-                });
-                if (downloadResult.success && downloadResult.binaryPath) {
-                    binaryInfo = await detectScipBinary(language);
-                }
-                else {
-                    const manualInstr = getManualInstallInstructions(language);
-                    log.warn(`SCIP auto-download failed for ${language}: ${downloadResult.error}${manualInstr ? `\n  Manual install: ${manualInstr}` : ""}`);
-                    continue;
-                }
-            }
-        }
-        if (!binaryInfo.available) {
-            log.info(`SCIP binary not available for ${language}, skipping`);
-            continue;
-        }
-        // Step 4: Resolve language-specific options. Pre-flight (build-tool /
-        // compdb / tsconfig checks) may prompt the user — defer the
-        // "processing"/"enrichment" announce logs until AFTER pre-flight so the
-        // prompt zone isn't bracketed by SCIP log lines.
-        const outputDir = join(projectRoot, ".unerr", "scip");
-        const binaryPath = binaryInfo.path ?? binaryInfo.binaryName;
-        let extraArgs;
-        if (language === "typescript") {
-            // scip-typescript requires a tsconfig.json (or jsconfig.json) to resolve the project
-            if (!existsSync(join(projectRoot, "tsconfig.json")) &&
-                !existsSync(join(projectRoot, "jsconfig.json"))) {
-                log.info("SCIP skipping TypeScript: no tsconfig.json or jsconfig.json found in project root. Create one to enable SCIP indexing.");
-                continue;
-            }
-        }
-        if (language === "java") {
-            const buildToolResult = await resolveJavaBuildTool(projectRoot, options);
-            if (buildToolResult) {
-                extraArgs = buildToolResult.extraArgs;
-            }
-        }
-        if (language === "cpp") {
-            const compdbPath = resolveCompileCommandsJson(projectRoot);
-            if (!compdbPath) {
-                log.info("SCIP skipping C/C++: no compile_commands.json found. Generate one with CMake (-DCMAKE_EXPORT_COMPILE_COMMANDS=ON), Bear, or your build system.");
-                continue;
-            }
-            extraArgs = [`--compdb-path=${compdbPath}`];
-        }
-        // Pre-flight is done — safe to announce now that any interactive prompts
-        // have been resolved and won't be visually wedged between these logs.
-        log.info(`SCIP: processing ${language} (${fileCount} files)`);
-        log.info(`SCIP enrichment: ${language} (${binaryInfo.bundled ? "bundled" : "external"}: ${binaryInfo.binaryName})`);
-        const runResult = await runScipIndexer({
-            language,
-            binaryPath,
-            projectRoot,
-            outputDir,
-            timeoutMs: 30_000,
-            extraArgs,
-        });
-        lastRunResult = runResult;
-        if (!runResult.success || !runResult.outputPath) {
-            log.warn(`SCIP indexer failed for ${language}: ${runResult.error}`);
-            continue;
-        }
-        // Step 5: Decode protobuf output
-        const decodeResult = await decodeScipOutput(runResult.outputPath);
-        lastDecodeResult = decodeResult;
-        // Step 6: Merge with current edges (accumulates across languages)
-        const indexedEdges = currentEdges.map((e) => ({
-            from_key: e.from_key,
-            to_key: e.to_key,
-            type: e.type,
-            file_path: e.file_path,
-            line: e.line,
-        }));
-        const { edges: enrichedEdges, result: mergeResult } = mergeScipResults(indexedEdges, decodeResult, entities);
-        currentEdges = enrichedEdges;
-        lastMergeResult = mergeResult;
-        anySucceeded = true;
-        processedLanguages.push(language);
-        log.info(`SCIP ${language}: ${mergeResult.edgesUpgraded} edges upgraded to compiler-verified (${Math.round(runResult.durationMs)}ms)`);
-    }
-    if (!anySucceeded) {
-        return skipResult(existingEdges, `No SCIP binary available for any detected language (${languages.map((l) => l.language).join(", ")})`);
-    }
-    return {
-        language: processedLanguages.join("+"),
-        binaryAvailable: true,
-        bundled: false,
-        runResult: lastRunResult,
-        decodeResult: lastDecodeResult,
-        mergeResult: lastMergeResult,
-        enrichedEdges: currentEdges,
-        skipped: false,
-        skipReason: null,
-    };
-}
-import { writeNeedsInput } from "../../../daemon/registry.js";
-const BUILD_TOOL_FILES = {
-    Maven: ["pom.xml"],
-    Gradle: [
-        "build.gradle",
-        "build.gradle.kts",
-        "settings.gradle",
-        "settings.gradle.kts",
-    ],
-    Bazel: ["BUILD", "BUILD.bazel", "WORKSPACE", "WORKSPACE.bazel"],
-    Sbt: ["build.sbt"],
-};
-const WRAPPER_FILES = {
-    gradlew: "Gradle",
-    "gradlew.bat": "Gradle",
-    mvnw: "Maven",
-    "mvnw.cmd": "Maven",
-};
-/** Detect Java build tools present in the project root. */
-export function detectJavaBuildTools(projectRoot) {
-    const detected = [];
-    for (const [tool, files] of Object.entries(BUILD_TOOL_FILES)) {
-        if (files.some((f) => existsSync(join(projectRoot, f)))) {
-            detected.push(tool);
-        }
-    }
-    return detected;
-}
-/** Read stored Java build tool preference from .unerr/config.json. */
-function getStoredBuildTool(projectRoot) {
-    try {
-        const configPath = join(projectRoot, ".unerr", "config.json");
-        const config = JSON.parse(readFileSync(configPath, "utf-8"));
-        return config.javaBuildTool ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Store Java build tool preference in .unerr/config.json. */
-function storeBuildTool(projectRoot, tool) {
-    const configPath = join(projectRoot, ".unerr", "config.json");
-    let config = {};
-    try {
-        config = JSON.parse(readFileSync(configPath, "utf-8"));
-    }
-    catch {
-        /* new config */
-    }
-    config.javaBuildTool = tool;
-    const dir = join(projectRoot, ".unerr");
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
-}
-/**
- * Pure-function build tool chooser — deterministic, no TTY interaction.
- *
- * Priority chain (when multiple tools detected):
- *   (a) Explicit config → use it
- *   (b) Exactly one tool → use it
- *   (c) Any tool + Bazel → Bazel (polyglot/monorepo signal)
- *   (d) Any tool + Sbt → Sbt (Scala-first signal)
- *   (e) Maven + Gradle → prefer the one with a wrapper (gradlew/mvnw)
- *   (f) Tie: prefer the tool whose build files have more recent mtime
- */
-export function chooseBuildTool(detected, projectRoot) {
-    if (detected.length === 0)
-        return null;
-    if (detected.length === 1) {
-        return {
-            tool: detected[0],
-            reason: "sole build tool detected",
-            alternatives: [],
-            ambiguous: false,
-        };
-    }
-    // (c) Bazel takes precedence over everything
-    if (detected.includes("Bazel")) {
-        return {
-            tool: "Bazel",
-            reason: "Bazel present (polyglot/monorepo signal)",
-            alternatives: detected.filter((t) => t !== "Bazel"),
-            ambiguous: true,
-        };
-    }
-    // (d) Sbt takes precedence (Scala-first)
-    if (detected.includes("Sbt")) {
-        return {
-            tool: "Sbt",
-            reason: "Sbt present (Scala-first project)",
-            alternatives: detected.filter((t) => t !== "Sbt"),
-            ambiguous: true,
-        };
-    }
-    // (e) Maven + Gradle: check for wrappers
-    if (detected.includes("Maven") && detected.includes("Gradle")) {
-        const hasGradlew = existsSync(join(projectRoot, "gradlew")) ||
-            existsSync(join(projectRoot, "gradlew.bat"));
-        const hasMvnw = existsSync(join(projectRoot, "mvnw")) ||
-            existsSync(join(projectRoot, "mvnw.cmd"));
-        if (hasGradlew && !hasMvnw) {
-            return {
-                tool: "Gradle",
-                reason: "gradlew wrapper present",
-                alternatives: ["Maven"],
-                ambiguous: true,
-            };
-        }
-        if (hasMvnw && !hasGradlew) {
-            return {
-                tool: "Maven",
-                reason: "mvnw wrapper present",
-                alternatives: ["Gradle"],
-                ambiguous: true,
-            };
-        }
-        // Both or neither wrapper — fall through to mtime tiebreaker
-    }
-    // (f) Tiebreak by most recent build-file mtime
-    return tiebreakByMtime(detected, projectRoot);
-}
-/** Pick the tool whose build files have the most recent mtime. */
-function tiebreakByMtime(tools, projectRoot) {
-    let best = tools[0];
-    let bestMtime = 0;
-    for (const tool of tools) {
-        const files = BUILD_TOOL_FILES[tool];
-        for (const f of files) {
-            try {
-                const mt = statSync(join(projectRoot, f)).mtimeMs;
-                if (mt > bestMtime) {
-                    bestMtime = mt;
-                    best = tool;
-                }
-            }
-            catch {
-                // file doesn't exist for this tool
-            }
-        }
-    }
-    return {
-        tool: best,
-        reason: `most recently modified build file (${best})`,
-        alternatives: tools.filter((t) => t !== best),
-        ambiguous: true,
-    };
-}
-/**
- * Resolve the Java build tool for scip-java --build-tool flag.
- *
- * Deterministic, pure-function resolution — no interactive prompts,
- * no process.stdin.isTTY checks. Works identically under TTY and headless.
- *
- * Priority:
- *   1. Explicit config in .unerr/config.json → use it
- *   2. Exactly one detected → use it
- *   3. Multiple → chooseBuildTool heuristic
- *   4. Cache choice + emit needs_input signal for ambiguous picks
- */
-async function resolveJavaBuildTool(projectRoot, _options) {
-    const detected = detectJavaBuildTools(projectRoot);
-    if (detected.length === 0)
-        return null;
-    // Explicit config takes absolute precedence
-    const stored = getStoredBuildTool(projectRoot);
-    if (stored && detected.includes(stored)) {
-        log.info(`Java build tool: ${stored} (from config)`);
-        return { tool: stored, extraArgs: [`--build-tool=${stored}`] };
-    }
-    const choice = chooseBuildTool(detected, projectRoot);
-    if (!choice)
-        return null;
-    // Cache the deterministic choice for O(1) subsequent boots
-    storeBuildTool(projectRoot, choice.tool);
-    // Emit needs_input signal when the choice was ambiguous
-    if (choice.ambiguous) {
-        const signal = {
-            type: "needs_input",
-            key: "javaBuildTool",
-            auto: choice.tool,
-            alternatives: choice.alternatives,
-            reason: choice.reason,
-        };
-        writeNeedsInput(projectRoot, [signal]);
-        log.info(`Java build tool: ${choice.tool} (auto: ${choice.reason}). Override: unerr daemon config . --java-build-tool=<tool>`);
-    }
-    else {
-        log.info(`Java build tool: ${choice.tool} (${choice.reason})`);
-    }
-    return {
-        tool: choice.tool,
-        extraArgs: [`--build-tool=${choice.tool}`],
-    };
-}
-// ── C/C++ Compile Commands Detection ─────────────────────────────
-/** Common locations for compile_commands.json in C/C++ projects. */
-const COMPDB_SEARCH_PATHS = [
-    "compile_commands.json",
-    "build/compile_commands.json",
-    "cmake-build-debug/compile_commands.json",
-    "cmake-build-release/compile_commands.json",
-    "out/compile_commands.json",
-];
-/**
- * Find compile_commands.json in the project.
- * scip-clang requires a compilation database to index C/C++ code.
- * Returns the absolute path if found, null otherwise.
- */
-function resolveCompileCommandsJson(projectRoot) {
-    for (const relPath of COMPDB_SEARCH_PATHS) {
-        const absPath = join(projectRoot, relPath);
-        if (existsSync(absPath)) {
-            log.info(`Found compile_commands.json at ${relPath}`);
-            return absPath;
-        }
-    }
-    return null;
-}
-// ── C# scip-dotnet Installation ──────────────────────────────────
-/**
- * Install scip-dotnet via `dotnet tool install`.
- * Requires the .NET SDK (dotnet CLI) to be on PATH.
- * Returns true if installation succeeded, false otherwise.
- */
-async function installScipDotnet() {
-    // Check if dotnet is available
-    try {
-        const dotnetCheck = await exec("which", ["dotnet"]);
-        if (dotnetCheck.exitCode !== 0) {
-            log.warn("SCIP skipping C#: dotnet CLI not found on PATH. Install the .NET SDK to enable SCIP indexing for C#.");
-            return false;
-        }
-    }
-    catch {
-        log.warn("SCIP skipping C#: dotnet CLI not found on PATH. Install the .NET SDK to enable SCIP indexing for C#.");
-        return false;
-    }
-    log.info("Installing scip-dotnet via dotnet tool install...");
-    try {
-        const result = await exec("dotnet", [
-            "tool",
-            "install",
-            "--global",
-            "scip-dotnet",
-        ]);
-        if (result.exitCode === 0) {
-            log.info("scip-dotnet installed successfully");
-            return true;
-        }
-        // Exit code 1 with "already installed" is OK
-        if (result.stderr.includes("already installed")) {
-            log.info("scip-dotnet already installed");
-            return true;
-        }
-        log.warn(`scip-dotnet install failed: ${result.stderr.slice(0, 300)}`);
-        return false;
-    }
-    catch (err) {
-        log.warn(`scip-dotnet install failed: ${err instanceof Error ? err.message : String(err)}`);
-        return false;
-    }
-}
-function skipResult(existingEdges, reason) {
-    log.info(`SCIP skipped: ${reason}`);
-    return {
-        language: null,
-        binaryAvailable: false,
-        bundled: false,
-        runResult: null,
-        decodeResult: null,
-        mergeResult: null,
-        enrichedEdges: markAsStructural(existingEdges),
-        skipped: true,
-        skipReason: reason,
-    };
-}
-function markAsStructural(edges) {
-    return edges.map((e) => ({
-        ...e,
-        confidence: "structural",
-        scipVerified: false,
-    }));
-}

package/dist/intelligence/indexer/scip/runner.js

@@ -1,98 +0,0 @@
-/**
- * SCIP Invocation Runner — spawns SCIP binary, captures protobuf output.
- *
- * For bundled binaries (TypeScript), uses the resolved path directly from
- * node_modules/.bin. For external binaries, uses the PATH-resolved name.
- *
- * Resource-safe: respects timeout (30s default for inline indexing).
- */
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { exec } from "../../../utils/exec.js";
-import { createModuleLogger } from "../../../utils/logger.js";
-const log = createModuleLogger("scip-runner");
-/**
- * Run a SCIP indexer and capture the output.
- * Default timeout is 30s (inline indexing — not background).
- */
-export async function runScipIndexer(options) {
-    const start = performance.now();
-    const { language, binaryPath, projectRoot, outputDir, timeoutMs = 30_000, } = options;
-    if (!existsSync(outputDir)) {
-        mkdirSync(outputDir, { recursive: true });
-    }
-    const outputPath = join(outputDir, "index.scip");
-    const args = buildScipArgs(language, binaryPath, projectRoot, outputPath);
-    if (options.extraArgs?.length) {
-        args.push(...options.extraArgs);
-    }
-    try {
-        log.info(`Running SCIP indexer: ${args[0]} for ${language}`);
-        const result = await exec(args[0], args.slice(1), {
-            cwd: projectRoot,
-            timeout: timeoutMs,
-        });
-        const durationMs = performance.now() - start;
-        if (result.exitCode !== 0) {
-            // Some SCIP indexers (e.g. scip-java via Maven) exit non-zero due to
-            // JVM deprecation warnings (sun.misc.Unsafe) even when indexing succeeds.
-            // If the output file was created despite the non-zero exit, treat as success.
-            if (existsSync(outputPath)) {
-                log.warn(`SCIP indexer exited with code ${result.exitCode} but output file was created — treating as success`);
-                return { success: true, outputPath, durationMs, error: null };
-            }
-            log.warn(`SCIP indexer failed (exit ${result.exitCode}): ${result.stderr.slice(0, 500)}`);
-            return {
-                success: false,
-                outputPath: null,
-                durationMs,
-                error: result.stderr.slice(0, 500),
-            };
-        }
-        if (!existsSync(outputPath)) {
-            return {
-                success: false,
-                outputPath: null,
-                durationMs,
-                error: "SCIP output file not created",
-            };
-        }
-        log.info(`SCIP indexer completed in ${Math.round(durationMs)}ms`);
-        return { success: true, outputPath, durationMs, error: null };
-    }
-    catch (err) {
-        const durationMs = performance.now() - start;
-        const message = err instanceof Error ? err.message : String(err);
-        log.warn(`SCIP indexer error: ${message}`);
-        return { success: false, outputPath: null, durationMs, error: message };
-    }
-}
-function buildScipArgs(language, binaryPath, projectRoot, outputPath) {
-    switch (language) {
-        case "typescript":
-            return [binaryPath, "index", "--output", outputPath];
-        case "python":
-            return [
-                binaryPath,
-                "index",
-                "--cwd",
-                projectRoot,
-                "--output",
-                outputPath,
-            ];
-        case "go":
-            return [binaryPath, "-o", outputPath, "./..."];
-        case "java":
-            return [binaryPath, "index", "--output", outputPath];
-        case "rust":
-            return [binaryPath, "scip", projectRoot, "--output", outputPath];
-        case "ruby":
-            return [binaryPath, "--output", outputPath];
-        case "cpp":
-            return [binaryPath, "--output", outputPath];
-        case "csharp":
-            return [binaryPath, "index", "--output", outputPath];
-        default:
-            return [binaryPath, "--output", outputPath];
-    }
-}

package/dist/intelligence/indexer/snapshot.js

@@ -1,66 +0,0 @@
-/**
- * Index Snapshot — save/load the full index state as msgpack for cold start.
- *
- * When the proxy restarts, instead of re-indexing the entire project,
- * it loads the snapshot and only incrementally indexes changed files.
- *
- * Snapshot format: { entities, edges, metadata, version }
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { createModuleLogger } from "../../utils/logger.js";
-const log = createModuleLogger("index-snapshot");
-const SNAPSHOT_VERSION = 1;
-/**
- * Save index state as a snapshot.
- */
-export function saveSnapshot(unerrDir, entities, edges, metadata) {
-    const indexDir = join(unerrDir, "index");
-    if (!existsSync(indexDir)) {
-        mkdirSync(indexDir, { recursive: true });
-    }
-    const snapshot = {
-        version: SNAPSHOT_VERSION,
-        entities,
-        edges,
-        metadata,
-        savedAt: new Date().toISOString(),
-    };
-    const snapshotPath = join(indexDir, "snapshot.json");
-    try {
-        writeFileSync(snapshotPath, JSON.stringify(snapshot), "utf-8");
-        log.info(`Snapshot saved: ${entities.length} entities, ${edges.length} edges`);
-    }
-    catch (err) {
-        log.warn(`Failed to save snapshot: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-/**
- * Load index snapshot from disk.
- * Returns null if no valid snapshot exists.
- */
-export function loadSnapshot(unerrDir) {
-    const snapshotPath = join(unerrDir, "index", "snapshot.json");
-    if (!existsSync(snapshotPath))
-        return null;
-    try {
-        const raw = readFileSync(snapshotPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        if (parsed.version !== SNAPSHOT_VERSION) {
-            log.info("Snapshot version mismatch — full re-index needed");
-            return null;
-        }
-        log.info(`Snapshot loaded: ${parsed.entities.length} entities, ${parsed.edges.length} edges (saved ${parsed.savedAt})`);
-        return parsed;
-    }
-    catch (err) {
-        log.warn(`Failed to load snapshot: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-}
-/**
- * Check if a valid snapshot exists.
- */
-export function hasSnapshot(unerrDir) {
-    return existsSync(join(unerrDir, "index", "snapshot.json"));
-}