@unerr-ai/unerr 0.0.1 → 0.1.1

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

@@ -0,0 +1,253 @@
+/**
+ * SCIP Protobuf Decoder — reads SCIP index output and extracts symbol occurrences.
+ *
+ * SCIP output is a protobuf-encoded Index message (scip.proto schema).
+ * Structure:
+ *   Index {
+ *     documents: Document[]  (field 1)
+ *   }
+ *   Document {
+ *     language: string       (field 1)
+ *     relative_path: string  (field 4)
+ *     occurrences: Occurrence[] (field 3)
+ *     symbols: SymbolInformation[] (field 2)
+ *   }
+ *   Occurrence {
+ *     range: int32[]         (field 1, packed varint)
+ *     symbol: string         (field 2)
+ *     symbol_roles: int32    (field 3, bit 0 = Definition)
+ *   }
+ *
+ * We implement a minimal protobuf decoder — no external dependency needed.
+ */
+import { readFileSync } from "node:fs";
+import { createModuleLogger } from "../../../utils/logger.js";
+const log = createModuleLogger("scip-decoder");
+/**
+ * Decode a SCIP protobuf output file into structured symbol occurrences.
+ */
+export async function decodeScipOutput(filePath) {
+    const start = performance.now();
+    let buffer;
+    try {
+        buffer = readFileSync(filePath);
+    }
+    catch {
+        return emptyResult(start);
+    }
+    if (buffer.length === 0)
+        return emptyResult(start);
+    const documents = [];
+    let symbolCount = 0;
+    let definitionCount = 0;
+    let referenceCount = 0;
+    try {
+        // Parse top-level Index message
+        // SCIP proto: field 1 = metadata, field 2 = documents (repeated)
+        let offset = 0;
+        while (offset < buffer.length) {
+            const field = readField(buffer, offset);
+            if (!field)
+                break;
+            offset = field.nextOffset;
+            // field 2 = documents (length-delimited)
+            if (field.fieldNumber === 2 && field.wireType === 2) {
+                const doc = parseDocument(field.data);
+                if (doc?.relativePath) {
+                    documents.push(doc);
+                    symbolCount += doc.symbols.length;
+                    definitionCount += doc.symbols.filter((s) => s.isDefinition).length;
+                    referenceCount += doc.symbols.filter((s) => !s.isDefinition).length;
+                }
+            }
+        }
+    }
+    catch (err) {
+        log.warn(`SCIP decode error: ${err instanceof Error ? err.message : String(err)} (decoded ${documents.length} docs before failure)`);
+    }
+    const durationMs = performance.now() - start;
+    log.info(`SCIP decoded: ${documents.length} docs, ${symbolCount} symbols (${definitionCount} defs, ${referenceCount} refs) in ${Math.round(durationMs)}ms`);
+    return {
+        documents,
+        symbolCount,
+        definitionCount,
+        referenceCount,
+        durationMs,
+    };
+}
+// ── Document Parsing ────────────────────────────────���─────────────
+function parseDocument(data) {
+    let relativePath = "";
+    const occurrenceBuffers = [];
+    let offset = 0;
+    while (offset < data.length) {
+        const field = readField(data, offset);
+        if (!field)
+            break;
+        offset = field.nextOffset;
+        switch (field.fieldNumber) {
+            case 1: // relative_path (string) — scip-typescript puts path in field 1
+                if (field.wireType === 2) {
+                    relativePath = field.data.toString("utf-8");
+                }
+                break;
+            case 2: // occurrences (repeated Occurrence message)
+                if (field.wireType === 2) {
+                    occurrenceBuffers.push(field.data);
+                }
+                break;
+            case 4: // relative_path in older SCIP versions
+                if (field.wireType === 2 && !relativePath) {
+                    relativePath = field.data.toString("utf-8");
+                }
+                break;
+        }
+    }
+    if (!relativePath)
+        return null;
+    // Parse occurrences now that we have the file path
+    const symbols = [];
+    for (const buf of occurrenceBuffers) {
+        const occ = parseOccurrence(buf, relativePath);
+        if (occ)
+            symbols.push(occ);
+    }
+    return { relativePath, symbols };
+}
+// ── Occurrence Parsing ────────────────────────────────────────────
+function parseOccurrence(data, filePath) {
+    let symbol = "";
+    let line = 0;
+    let symbolRoles = 0;
+    let offset = 0;
+    while (offset < data.length) {
+        const field = readField(data, offset);
+        if (!field)
+            break;
+        offset = field.nextOffset;
+        switch (field.fieldNumber) {
+            case 1: // range (packed repeated int32) — [startLine, startChar, endChar] or [startLine, startChar, endLine, endChar]
+                if (field.wireType === 2) {
+                    const rangeData = field.data;
+                    const values = decodePackedVarints(rangeData);
+                    if (values.length >= 1)
+                        line = values[0];
+                }
+                else if (field.wireType === 0) {
+                    // Non-packed (shouldn't happen for range but handle gracefully)
+                    line = field.data;
+                }
+                break;
+            case 2: // symbol (string)
+                if (field.wireType === 2) {
+                    symbol = field.data.toString("utf-8");
+                }
+                break;
+            case 3: // symbol_roles (int32, bit 0 = Definition)
+                if (field.wireType === 0) {
+                    symbolRoles = field.data;
+                }
+                break;
+        }
+    }
+    if (!symbol)
+        return null;
+    return {
+        symbol,
+        filePath,
+        line,
+        isDefinition: (symbolRoles & 0x01) !== 0,
+    };
+}
+/** Decode a packed varint array from a buffer. */
+function decodePackedVarints(buf) {
+    const values = [];
+    let offset = 0;
+    while (offset < buf.length) {
+        const result = readVarint(buf, offset);
+        if (!result)
+            break;
+        values.push(result.value);
+        offset = result.offset;
+    }
+    return values;
+}
+function readField(buffer, offset) {
+    if (offset >= buffer.length)
+        return null;
+    const tagResult = readVarint(buffer, offset);
+    if (!tagResult)
+        return null;
+    const tag = tagResult.value;
+    const fieldNumber = tag >>> 3;
+    const wireType = tag & 0x07;
+    const nextOffset = tagResult.offset;
+    if (fieldNumber === 0)
+        return null; // Invalid field number
+    switch (wireType) {
+        case 0: {
+            // Varint
+            const valResult = readVarint(buffer, nextOffset);
+            if (!valResult)
+                return null;
+            return {
+                fieldNumber,
+                wireType,
+                data: valResult.value,
+                nextOffset: valResult.offset,
+            };
+        }
+        case 1: {
+            // 64-bit (skip 8 bytes)
+            return { fieldNumber, wireType, data: 0, nextOffset: nextOffset + 8 };
+        }
+        case 2: {
+            // Length-delimited
+            const lenResult = readVarint(buffer, nextOffset);
+            if (!lenResult)
+                return null;
+            const len = lenResult.value;
+            const dataStart = lenResult.offset;
+            if (dataStart + len > buffer.length)
+                return null;
+            return {
+                fieldNumber,
+                wireType,
+                data: buffer.subarray(dataStart, dataStart + len),
+                nextOffset: dataStart + len,
+            };
+        }
+        case 5: {
+            // 32-bit (skip 4 bytes)
+            return { fieldNumber, wireType, data: 0, nextOffset: nextOffset + 4 };
+        }
+        default:
+            return null; // Unknown wire type — stop parsing
+    }
+}
+function readVarint(buffer, offset) {
+    let value = 0;
+    let shift = 0;
+    let pos = offset;
+    while (pos < buffer.length) {
+        const byte = buffer[pos];
+        value |= (byte & 0x7f) << shift;
+        pos++;
+        if ((byte & 0x80) === 0) {
+            return { value: value >>> 0, offset: pos }; // unsigned
+        }
+        shift += 7;
+        if (shift > 35)
+            return null; // Overflow protection
+    }
+    return null;
+}
+function emptyResult(start) {
+    return {
+        documents: [],
+        symbolCount: 0,
+        definitionCount: 0,
+        referenceCount: 0,
+        durationMs: performance.now() - start,
+    };
+}

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

@@ -0,0 +1,232 @@
+/**
+ * SCIP Binary Detector — resolves SCIP indexer binaries.
+ *
+ * Strategy:
+ *   - TypeScript/JavaScript: BUNDLED as npm dependency (@sourcegraph/scip-typescript)
+ *   - Python: BUNDLED as npm dependency (@sourcegraph/scip-python)
+ *   - Go/Rust: AUTO-DOWNLOADED to ~/.unerr/bin/ on first use,
+ *     or detected on PATH if already installed.
+ *   - Java: Launcher script downloaded, requires JRE on PATH.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { exec } from "../../../utils/exec.js";
+import { getCachedBinaryPath } from "./downloader.js";
+/**
+ * Bundled SCIP tools — shipped as npm dependencies.
+ * These are ALWAYS available after `pnpm install`.
+ */
+const BUNDLED_SCIP = {
+    typescript: {
+        bin: "scip-typescript",
+        resolveFrom: "@sourcegraph/scip-typescript",
+    },
+    python: {
+        bin: "scip-python",
+        resolveFrom: "@sourcegraph/scip-python",
+    },
+};
+/**
+ * External SCIP tools — checked on PATH after download cache.
+ * Only languages with SCIP ✓ in README (Tier 1).
+ */
+const EXTERNAL_SCIP = {
+    go: ["scip-go"],
+    java: ["scip-java"],
+    rust: ["rust-analyzer"],
+    ruby: ["scip-ruby"],
+    cpp: ["scip-clang"],
+    csharp: ["scip-dotnet"],
+};
+/**
+ * Resolve the path to a bundled SCIP binary.
+ * Walks up from this file to find node_modules/.bin/<binary>.
+ */
+function resolveBundledBinary(binName) {
+    let dir = import.meta.dirname ?? __dirname;
+    for (let i = 0; i < 10; i++) {
+        const candidate = join(dir, "node_modules", ".bin", binName);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = join(dir, "..");
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Detect SCIP binary for a language.
+ *
+ * Resolution order:
+ *   1. Bundled (npm) — TypeScript, Python
+ *   2. Download cache (~/.unerr/bin/) — auto-downloaded binaries
+ *   3. PATH — user-installed binaries
+ *   4. Not available — orchestrator will attempt auto-download
+ */
+export async function detectScipBinary(language) {
+    // 1. Check bundled first (TypeScript, Python)
+    const bundled = BUNDLED_SCIP[language];
+    if (bundled) {
+        const binPath = resolveBundledBinary(bundled.bin);
+        if (binPath) {
+            return {
+                language,
+                binaryName: bundled.bin,
+                available: true,
+                bundled: true,
+                version: null,
+                path: binPath,
+            };
+        }
+        // Fallback: try npx (in case node_modules resolution fails)
+        return {
+            language,
+            binaryName: `npx ${bundled.bin}`,
+            available: true,
+            bundled: true,
+            version: null,
+            path: null,
+        };
+    }
+    // 2. Check download cache (~/.unerr/bin/)
+    const cachedPath = getCachedBinaryPath(language);
+    if (cachedPath) {
+        return {
+            language,
+            binaryName: cachedPath.split("/").pop() ?? `scip-${language}`,
+            available: true,
+            bundled: false,
+            version: null,
+            path: cachedPath,
+        };
+    }
+    // 3. Check external binaries on PATH
+    const candidates = EXTERNAL_SCIP[language] ?? [];
+    for (const candidate of candidates) {
+        try {
+            const whichResult = await exec("which", [candidate]);
+            if (whichResult.exitCode === 0) {
+                const versionResult = await exec(candidate, ["--version"]);
+                return {
+                    language,
+                    binaryName: candidate,
+                    available: true,
+                    bundled: false,
+                    version: versionResult.exitCode === 0
+                        ? (versionResult.stdout.split("\n")[0]?.trim() ?? null)
+                        : null,
+                    path: whichResult.stdout.trim() || null,
+                };
+            }
+        }
+        catch { }
+    }
+    // 4. Not available — caller should attempt auto-download
+    return {
+        language,
+        binaryName: candidates[0] ?? `scip-${language}`,
+        available: false,
+        bundled: false,
+        version: null,
+        path: null,
+    };
+}
+/**
+ * Extension → SCIP language mapping.
+ * Only languages with SCIP support (Tier 1 with SCIP ✓ in README).
+ */
+const EXT_TO_SCIP_LANG = {
+    // TypeScript / JavaScript (scip-typescript handles all)
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "typescript",
+    ".jsx": "typescript",
+    ".mjs": "typescript",
+    ".cjs": "typescript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    // Python
+    ".py": "python",
+    ".pyi": "python",
+    ".pyx": "python",
+    // Go
+    ".go": "go",
+    // Java / Kotlin / Scala (JVM — scip-java handles all)
+    ".java": "java",
+    ".kt": "java",
+    ".kts": "java",
+    ".scala": "java",
+    ".sc": "java",
+    // Rust
+    ".rs": "rust",
+    // Ruby
+    ".rb": "ruby",
+    // C / C++ (scip-clang handles both)
+    ".c": "cpp",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".h": "cpp",
+    ".hpp": "cpp",
+    ".hxx": "cpp",
+    // C#
+    ".cs": "csharp",
+};
+/**
+ * Detect the primary language of a project from file extensions.
+ * Returns the language with the most source files.
+ */
+export function detectPrimaryLanguage(files) {
+    const counts = {};
+    for (const file of files) {
+        const dotIdx = file.lastIndexOf(".");
+        if (dotIdx === -1)
+            continue;
+        const ext = file.slice(dotIdx);
+        const lang = EXT_TO_SCIP_LANG[ext];
+        if (lang) {
+            counts[lang] = (counts[lang] ?? 0) + 1;
+        }
+    }
+    let maxLang = null;
+    let maxCount = 0;
+    for (const [lang, count] of Object.entries(counts)) {
+        if (count > maxCount) {
+            maxCount = count;
+            maxLang = lang;
+        }
+    }
+    return maxLang;
+}
+/**
+ * Detect ALL languages present in the project (for multi-language SCIP).
+ * Returns languages sorted by file count (primary first).
+ */
+export function detectProjectLanguages(files) {
+    const counts = {};
+    for (const file of files) {
+        const dotIdx = file.lastIndexOf(".");
+        if (dotIdx === -1)
+            continue;
+        const ext = file.slice(dotIdx);
+        const lang = EXT_TO_SCIP_LANG[ext];
+        if (lang) {
+            counts[lang] = (counts[lang] ?? 0) + 1;
+        }
+    }
+    return Object.entries(counts)
+        .map(([language, fileCount]) => ({ language, fileCount }))
+        .sort((a, b) => b.fileCount - a.fileCount);
+}
+/**
+ * Get all languages that have SCIP support (bundled or detected).
+ */
+export async function getAvailableScipLanguages() {
+    const allLangs = [
+        ...Object.keys(BUNDLED_SCIP),
+        ...Object.keys(EXTERNAL_SCIP),
+    ];
+    const results = await Promise.all(allLangs.map(detectScipBinary));
+    return results.filter((r) => r.available);
+}