@unerr-ai/unerr 0.2.1 → 0.2.2

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

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

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