@unerr-ai/unerr 0.2.0 → 0.2.2

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

@@ -1,427 +0,0 @@
-/**
- * SCIP Binary Downloader — auto-downloads SCIP indexer binaries for detected languages.
- *
- * Downloads from GitHub releases, caches in ~/.unerr/bin/ for reuse across projects.
- * Users never need to know about SCIP — it just works during onboarding.
- *
- * Supported auto-download languages:
- *   - Go: scip-go binary from scip-code/scip-go releases
- *   - Java: scip-java launcher script from sourcegraph/scip-java releases (requires JRE)
- *   - Rust: rust-analyzer binary from rust-lang/rust-analyzer releases
- *
- * TypeScript/Python are BUNDLED as npm deps — never downloaded here.
- */
-import { chmodSync, createWriteStream, existsSync, mkdirSync } from "node:fs";
-import { rename, rm, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { pipeline } from "node:stream/promises";
-import { createGunzip } from "node:zlib";
-import { createModuleLogger } from "../../../utils/logger.js";
-const log = createModuleLogger("scip-downloader");
-/** Where downloaded SCIP binaries live — shared across all projects. */
-export function getScipBinDir() {
-    return join(homedir(), ".unerr", "bin");
-}
-/**
- * Download specs for each language's SCIP indexer.
- * Asset names verified against actual GitHub release assets.
- */
-const DOWNLOAD_SPECS = {
-    go: {
-        language: "go",
-        binaryName: "scip-go",
-        repo: "scip-code/scip-go", // transferred from sourcegraph/scip-go
-        tag: "latest",
-        // Verified assets: scip-go-darwin-arm64.tar.gz, scip-go-linux-amd64.tar.gz, scip-go-linux-arm64.tar.gz
-        // NOTE: No darwin-amd64 (Intel Mac) build available
-        resolveAssetName: (p) => {
-            const os = p.os;
-            const arch = p.nodeArch === "arm64" ? "arm64" : "amd64";
-            // No darwin-amd64 build exists
-            if (os === "darwin" && arch === "amd64")
-                return null;
-            if (os === "windows")
-                return null;
-            return `scip-go-${os}-${arch}.tar.gz`;
-        },
-        archiveType: "tar.gz",
-        archiveBinaryPath: "scip-go",
-        manualInstall: "go install github.com/scip-code/scip-go/cmd/scip-go@latest",
-    },
-    java: {
-        language: "java",
-        binaryName: "scip-java",
-        repo: "sourcegraph/scip-java",
-        tag: "latest",
-        // Verified assets: scip-java-v{ver} (unix script), scip-java-v{ver}.bat (windows)
-        // The script is a Coursier launcher — requires JRE on PATH
-        resolveAssetName: (p) => {
-            if (p.os === "windows")
-                return null; // .bat not supported yet
-            return null; // Asset name includes version, resolved dynamically
-        },
-        archiveType: "raw",
-        archiveBinaryPath: null,
-        manualInstall: "Download from https://github.com/sourcegraph/scip-java/releases (requires JRE)",
-    },
-    rust: {
-        language: "rust",
-        binaryName: "rust-analyzer",
-        repo: "rust-lang/rust-analyzer",
-        tag: "latest",
-        // Verified assets: rust-analyzer-{triple}.gz (darwin, linux), rust-analyzer-{triple}.zip (windows)
-        resolveAssetName: (p) => {
-            if (p.os === "windows")
-                return null; // .zip extraction not implemented
-            return `rust-analyzer-${p.rustTriple}.gz`;
-        },
-        archiveType: "gz",
-        archiveBinaryPath: null,
-        manualInstall: "rustup component add rust-analyzer",
-    },
-    ruby: {
-        language: "ruby",
-        binaryName: "scip-ruby",
-        repo: "sourcegraph/scip-ruby",
-        tag: "latest",
-        // Verified assets: scip-ruby-arm64-darwin, scip-ruby-x86_64-linux (raw binaries)
-        // No darwin-x86_64 or linux-arm64 builds available
-        resolveAssetName: (p) => {
-            if (p.os === "windows")
-                return null;
-            if (p.os === "darwin" && p.nodeArch !== "arm64")
-                return null;
-            if (p.os === "linux" && p.nodeArch !== "x64")
-                return null;
-            const arch = p.os === "darwin" ? "arm64" : "x86_64";
-            return `scip-ruby-${arch}-${p.os}`;
-        },
-        archiveType: "raw",
-        archiveBinaryPath: null,
-        manualInstall: "Download from https://github.com/sourcegraph/scip-ruby/releases",
-    },
-    cpp: {
-        language: "cpp",
-        binaryName: "scip-clang",
-        repo: "sourcegraph/scip-clang",
-        tag: "latest",
-        // Verified assets: scip-clang-arm64-darwin, scip-clang-x86_64-linux (raw binaries)
-        // No darwin-x86_64 or linux-arm64 builds available
-        resolveAssetName: (p) => {
-            if (p.os === "windows")
-                return null;
-            if (p.os === "darwin" && p.nodeArch !== "arm64")
-                return null;
-            if (p.os === "linux" && p.nodeArch !== "x64")
-                return null;
-            const arch = p.os === "darwin" ? "arm64" : "x86_64";
-            return `scip-clang-${arch}-${p.os}`;
-        },
-        archiveType: "raw",
-        archiveBinaryPath: null,
-        manualInstall: "Download from https://github.com/sourcegraph/scip-clang/releases (requires compile_commands.json)",
-    },
-};
-/**
- * Get the cached binary path for a language, or null if not cached.
- */
-export function getCachedBinaryPath(language) {
-    const spec = DOWNLOAD_SPECS[language];
-    if (!spec)
-        return null;
-    const binDir = getScipBinDir();
-    const binPath = join(binDir, spec.binaryName);
-    if (existsSync(binPath)) {
-        return binPath;
-    }
-    return null;
-}
-/**
- * Get the download spec for a language, if auto-download is supported.
- */
-export function getDownloadSpec(language) {
-    return DOWNLOAD_SPECS[language] ?? null;
-}
-/**
- * Get manual install instructions for a language.
- */
-export function getManualInstallInstructions(language) {
-    return DOWNLOAD_SPECS[language]?.manualInstall ?? null;
-}
-/**
- * Check if auto-download is supported for a language.
- */
-export function isAutoDownloadSupported(language) {
-    return language in DOWNLOAD_SPECS;
-}
-/**
- * Resolve platform identifiers for download URL construction.
- */
-export function resolvePlatform() {
-    const platform = process.platform;
-    const arch = process.arch;
-    const os = platform === "darwin"
-        ? "darwin"
-        : platform === "win32"
-            ? "windows"
-            : "linux";
-    const rustTriple = platform === "darwin"
-        ? arch === "arm64"
-            ? "aarch64-apple-darwin"
-            : "x86_64-apple-darwin"
-        : platform === "win32"
-            ? "x86_64-pc-windows-msvc"
-            : arch === "arm64"
-                ? "aarch64-unknown-linux-gnu"
-                : "x86_64-unknown-linux-gnu";
-    return {
-        os,
-        arch: arch === "arm64" ? "aarch64" : "x86_64",
-        nodeArch: arch,
-        rustTriple,
-    };
-}
-/**
- * Build the download URL for a SCIP binary.
- * Returns null if the platform is not supported for this language.
- */
-export function buildDownloadUrl(spec, platform, resolvedTag) {
-    const assetName = spec.resolveAssetName(platform);
-    if (!assetName)
-        return null;
-    return `https://github.com/${spec.repo}/releases/download/${resolvedTag}/${assetName}`;
-}
-/**
- * Resolve "latest" tag to actual tag name via GitHub API.
- * Follows redirects (repos may have been transferred).
- */
-async function resolveLatestRelease(repo) {
-    try {
-        const url = `https://api.github.com/repos/${repo}/releases/latest`;
-        const response = await fetch(url, {
-            headers: { Accept: "application/vnd.github.v3+json" },
-            signal: AbortSignal.timeout(10_000),
-            redirect: "follow",
-        });
-        if (!response.ok) {
-            log.warn(`GitHub API returned ${response.status} for ${repo}`);
-            return null;
-        }
-        const data = (await response.json());
-        return {
-            tag: data.tag_name,
-            assets: data.assets.map((a) => ({
-                name: a.name,
-                url: a.browser_download_url,
-            })),
-        };
-    }
-    catch (err) {
-        log.warn(`Failed to resolve latest release for ${repo}: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-}
-/**
- * Download and install a SCIP binary for the given language.
- *
- * Transparent during onboarding — users see progress, not implementation details.
- */
-export async function downloadScipBinary(language, onProgress) {
-    const spec = DOWNLOAD_SPECS[language];
-    if (!spec) {
-        return {
-            success: false,
-            binaryPath: null,
-            error: `No auto-download available for language: ${language}`,
-            fromCache: false,
-        };
-    }
-    // Check cache first
-    const cached = getCachedBinaryPath(language);
-    if (cached) {
-        return { success: true, binaryPath: cached, error: null, fromCache: true };
-    }
-    const binDir = getScipBinDir();
-    if (!existsSync(binDir)) {
-        mkdirSync(binDir, { recursive: true });
-    }
-    const platform = resolvePlatform();
-    const destPath = join(binDir, spec.binaryName);
-    try {
-        // Resolve latest release
-        onProgress?.(`Resolving latest ${spec.binaryName} version...`);
-        const release = await resolveLatestRelease(spec.repo);
-        if (!release) {
-            return {
-                success: false,
-                binaryPath: null,
-                error: `Could not resolve latest release for ${spec.repo}. Check your internet connection.`,
-                fromCache: false,
-            };
-        }
-        // For Java, the asset name includes the version tag — find it dynamically
-        let downloadUrl;
-        if (language === "java") {
-            const javaAsset = release.assets.find((a) => a.name.startsWith("scip-java-") &&
-                !a.name.endsWith(".bat") &&
-                !a.name.endsWith(".sha256"));
-            if (!javaAsset) {
-                return {
-                    success: false,
-                    binaryPath: null,
-                    error: `No compatible scip-java asset found in release ${release.tag}. ${spec.manualInstall}`,
-                    fromCache: false,
-                };
-            }
-            downloadUrl = javaAsset.url;
-        }
-        else {
-            downloadUrl = buildDownloadUrl(spec, platform, release.tag);
-        }
-        if (!downloadUrl) {
-            return {
-                success: false,
-                binaryPath: null,
-                error: `No ${spec.binaryName} binary available for ${platform.os}/${platform.nodeArch}. ${spec.manualInstall}`,
-                fromCache: false,
-            };
-        }
-        onProgress?.(`Downloading ${spec.binaryName} (${release.tag})...`);
-        log.info(`Downloading ${downloadUrl}`);
-        const response = await fetch(downloadUrl, {
-            signal: AbortSignal.timeout(120_000),
-            redirect: "follow",
-        });
-        if (!response.ok || !response.body) {
-            return {
-                success: false,
-                binaryPath: null,
-                error: `Download failed (HTTP ${response.status}). Try manually: ${spec.manualInstall}`,
-                fromCache: false,
-            };
-        }
-        onProgress?.(`Installing ${spec.binaryName}...`);
-        if (spec.archiveType === "tar.gz" && spec.archiveBinaryPath) {
-            await extractTarGz(response, spec.archiveBinaryPath, destPath);
-        }
-        else if (spec.archiveType === "gz") {
-            await extractGzSingle(response, destPath);
-        }
-        else {
-            await downloadToFile(response, destPath);
-        }
-        // Make executable
-        chmodSync(destPath, 0o755);
-        // Verify it exists and has size
-        const fileInfo = await stat(destPath);
-        if (fileInfo.size === 0) {
-            await rm(destPath, { force: true });
-            return {
-                success: false,
-                binaryPath: null,
-                error: `Downloaded binary is empty. Try manually: ${spec.manualInstall}`,
-                fromCache: false,
-            };
-        }
-        onProgress?.(`${spec.binaryName} installed successfully`);
-        log.info(`SCIP binary installed: ${destPath} (${fileInfo.size} bytes)`);
-        return {
-            success: true,
-            binaryPath: destPath,
-            error: null,
-            fromCache: false,
-        };
-    }
-    catch (err) {
-        // Clean up partial downloads
-        await rm(destPath, { force: true }).catch(() => { });
-        const message = err instanceof Error ? err.message : String(err);
-        log.warn(`Download failed for ${language}: ${message}`);
-        return {
-            success: false,
-            binaryPath: null,
-            error: `Download failed: ${message}. Try manually: ${spec.manualInstall}`,
-            fromCache: false,
-        };
-    }
-}
-/**
- * Extract a .tar.gz archive and pull out a specific binary.
- */
-async function extractTarGz(response, binaryPath, destPath) {
-    const { exec } = await import("../../../utils/exec.js");
-    const archivePath = `${destPath}.tar.gz`;
-    await downloadToFile(response, archivePath);
-    const extractDir = `${destPath}.extract`;
-    mkdirSync(extractDir, { recursive: true });
-    try {
-        const result = await exec("tar", ["xzf", archivePath, "-C", extractDir]);
-        if (result.exitCode !== 0) {
-            throw new Error(`tar extraction failed: ${result.stderr}`);
-        }
-        // Find the binary — it might be at root or nested
-        const { exec: execFind } = await import("../../../utils/exec.js");
-        const findResult = await execFind("find", [
-            extractDir,
-            "-name",
-            binaryPath,
-            "-type",
-            "f",
-        ]);
-        const foundPath = findResult.stdout.trim().split("\n")[0];
-        if (foundPath && existsSync(foundPath)) {
-            await rename(foundPath, destPath);
-        }
-        else {
-            const directPath = join(extractDir, binaryPath);
-            if (existsSync(directPath)) {
-                await rename(directPath, destPath);
-            }
-            else {
-                throw new Error(`Binary '${binaryPath}' not found in archive`);
-            }
-        }
-    }
-    finally {
-        await rm(archivePath, { force: true }).catch(() => { });
-        await rm(extractDir, { recursive: true, force: true }).catch(() => { });
-    }
-}
-/**
- * Extract a single .gz file (not tar.gz).
- */
-async function extractGzSingle(response, destPath) {
-    const gunzip = createGunzip();
-    const dest = createWriteStream(destPath);
-    const body = response.body;
-    if (!body)
-        throw new Error("No response body");
-    await pipeline(body, gunzip, dest);
-}
-/**
- * Download response body to a file.
- */
-async function downloadToFile(response, destPath) {
-    const body = response.body;
-    if (!body)
-        throw new Error("No response body");
-    const dest = createWriteStream(destPath);
-    await pipeline(body, dest);
-}
-/**
- * Get all languages that support auto-download.
- */
-export function getAutoDownloadLanguages() {
-    return Object.keys(DOWNLOAD_SPECS);
-}
-/**
- * Purge cached SCIP binaries (e.g., for updates or troubleshooting).
- */
-export async function purgeScipCache() {
-    const binDir = getScipBinDir();
-    if (existsSync(binDir)) {
-        await rm(binDir, { recursive: true, force: true });
-        log.info("SCIP binary cache purged");
-    }
-}

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

@@ -1,34 +0,0 @@
-/**
- * SCIP Graceful Degradation — handles all failure scenarios cleanly.
- *
- * - Binary not found → skip, log info, continue at Tier-2 quality
- * - Binary crashes → partial output → enrich what we have
- * - Timeout exceeded → kill process, use tree-sitter edges only
- * - Protobuf decode error → skip corrupted sections
- */
-import { createModuleLogger } from "../../../utils/logger.js";
-const log = createModuleLogger("scip-fallback");
-/**
- * Apply graceful degradation to edges when SCIP is unavailable or failed.
- */
-export function applyScipFallback(existingEdges, reason, level = "unavailable") {
-    log.info(`SCIP degradation (${level}): ${reason}`);
-    const edges = existingEdges.map((e) => ({
-        ...e,
-        confidence: "structural",
-        scipVerified: false,
-    }));
-    return { level, reason, edges };
-}
-/**
- * Determine degradation level from error type.
- */
-export function classifyScipError(error) {
-    if (error.includes("not found") || error.includes("ENOENT"))
-        return "unavailable";
-    if (error.includes("timeout") || error.includes("ETIMEDOUT"))
-        return "partial";
-    if (error.includes("decode") || error.includes("protobuf"))
-        return "partial";
-    return "unavailable";
-}

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

@@ -1,109 +0,0 @@
-/**
- * SCIP → Edge Enrichment Merger — upgrades tree-sitter edges to compiler-verified
- * and discovers new cross-file edges that tree-sitter missed.
- *
- * Matching strategy:
- *   SCIP gives us: symbol → (file, line, isDef/isRef)
- *   Graph gives us: entity (key, name, file_path) + edge (from_key, to_key, type)
- *
- *   We match by: SCIP definition at (file, name) confirms graph entity exists,
- *   and SCIP reference at (file, name) → SCIP definition at (other_file, name)
- *   confirms a cross-file call/import edge.
- */
-import { createModuleLogger } from "../../../utils/logger.js";
-const log = createModuleLogger("scip-merger");
-/**
- * Merge SCIP results with existing tree-sitter edges.
- *
- * @param existingEdges - Tree-sitter edges to enrich
- * @param scipResult - Decoded SCIP output
- * @param entities - Entity list for key→(file,name) resolution
- */
-export function mergeScipResults(existingEdges, scipResult, entities) {
-    const start = performance.now();
-    // Build SCIP definition index: normalized_name → Set<file_path>
-    const scipDefs = new Map();
-    for (const doc of scipResult.documents) {
-        for (const sym of doc.symbols) {
-            if (sym.isDefinition) {
-                const name = extractEntityName(sym.symbol);
-                if (name) {
-                    let files = scipDefs.get(name);
-                    if (!files) {
-                        files = new Set();
-                        scipDefs.set(name, files);
-                    }
-                    files.add(doc.relativePath);
-                }
-            }
-        }
-    }
-    // If we have entity data, build key→entity lookup for edge resolution
-    const entityByKey = new Map();
-    if (entities) {
-        for (const e of entities) {
-            entityByKey.set(e.key, e);
-        }
-    }
-    let edgesUpgraded = 0;
-    let edgesUnchanged = 0;
-    const enrichedEdges = existingEdges.map((edge) => {
-        if ((edge.type === "calls" || edge.type === "imports") &&
-            entityByKey.size > 0) {
-            const target = entityByKey.get(edge.to_key);
-            if (target) {
-                // Check if SCIP confirms this entity exists at this file
-                const defFiles = scipDefs.get(target.name);
-                if (defFiles?.has(target.file_path)) {
-                    edgesUpgraded++;
-                    return {
-                        ...edge,
-                        confidence: "compiler-verified",
-                        scipVerified: true,
-                    };
-                }
-                // Also try matching by last segment of name (for Class.method → method)
-                const baseName = target.name.split(".").pop();
-                if (baseName && baseName !== target.name) {
-                    const baseDefFiles = scipDefs.get(baseName);
-                    if (baseDefFiles?.has(target.file_path)) {
-                        edgesUpgraded++;
-                        return {
-                            ...edge,
-                            confidence: "compiler-verified",
-                            scipVerified: true,
-                        };
-                    }
-                }
-            }
-        }
-        edgesUnchanged++;
-        return { ...edge, confidence: "structural", scipVerified: false };
-    });
-    const durationMs = performance.now() - start;
-    log.info(`Merge: ${edgesUpgraded} upgraded, ${edgesUnchanged} unchanged (${scipDefs.size} unique SCIP definitions across ${scipResult.documents.length} files)`);
-    return {
-        edges: enrichedEdges,
-        result: {
-            edgesUpgraded,
-            edgesUnchanged,
-            newEdgesFromScip: 0,
-            durationMs,
-        },
-    };
-}
-/**
- * Extract a human-readable entity name from a SCIP symbol string.
- *
- * Examples:
- *   "scip-typescript npm unerr 0.1.0 src/`ignore.ts`/loadIgnore()." → "loadIgnore"
- *   "scip-typescript npm unerr 0.1.0 src/`local-graph.ts`/CozoGraphStore#getEntity()." → "getEntity"
- *   "scip-typescript npm unerr 0.1.0 src/`local-graph.ts`/CozoGraphStore#" → "CozoGraphStore"
- */
-function extractEntityName(symbol) {
-    // Remove trailing punctuation (., #, ().)
-    const cleaned = symbol.replace(/[().]+$/, "").replace(/#$/, "");
-    // Get the last segment after / or #
-    const match = cleaned.match(/[/#]([^/#`]+)$/);
-    return match?.[1] ?? null;
-}