@unerr-ai/unerr 0.0.1 → 0.1.1

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

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

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

@@ -0,0 +1,66 @@
+/**
+ * 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"));
+}