@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/intelligence/local-llm.js

@@ -1,163 +0,0 @@
-/**
- * BYO-LLM Adapter Factory — Provider-agnostic adapter for local LLM endpoints.
- *
- * Supports Ollama, LM Studio, OpenAI-compatible, and Anthropic-direct providers.
- * All adapters target the OpenAI-compatible /v1/embeddings endpoint pattern,
- * which Ollama, LM Studio, and generic OpenAI-compatible servers all expose.
- *
- * Anthropic-direct uses the /v1/messages endpoint for chat but still routes
- * embeddings through a local embedding server (the Anthropic API has no
- * embedding endpoint, so the adapter falls back to the configured baseUrl).
- *
- * SECURITY: API keys are NEVER logged to stderr, included in MCP responses,
- * or written to any ledger/file. They exist only in memory for Authorization headers.
- */
-import { resolveEmbeddingEndpoint } from "../config/settings.js";
-// ── Default Base URLs ────────────────────────────────────────
-const DEFAULT_BASE_URLS = {
-    ollama: "http://localhost:11434",
-    "lm-studio": "http://localhost:1234",
-    "openai-compatible": "http://localhost:8080",
-    "anthropic-direct": "https://api.anthropic.com",
-};
-class OpenAiCompatibleAdapter {
-    provider;
-    baseUrl;
-    embeddingModel;
-    embeddingDimensions;
-    maxConcurrency;
-    apiKey;
-    constructor(config, providerLabel) {
-        const endpoint = resolveEmbeddingEndpoint(config);
-        this.provider = providerLabel;
-        this.baseUrl =
-            endpoint.baseUrl ?? DEFAULT_BASE_URLS[endpoint.provider] ?? "";
-        this.embeddingModel = endpoint.model;
-        this.embeddingDimensions = config.embeddingDimensions;
-        this.maxConcurrency = config.maxConcurrency;
-        this.apiKey = endpoint.apiKey;
-    }
-    async embed(texts) {
-        if (texts.length === 0) {
-            return { embeddings: [], model: this.embeddingModel, totalTokens: 0 };
-        }
-        const url = `${this.baseUrl.replace(/\/+$/, "")}/v1/embeddings`;
-        const headers = {
-            "Content-Type": "application/json",
-        };
-        if (this.apiKey) {
-            headers.Authorization = `Bearer ${this.apiKey}`;
-        }
-        const response = await fetch(url, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({
-                model: this.embeddingModel,
-                input: texts,
-            }),
-        });
-        if (!response.ok) {
-            const body = await response.text().catch(() => "");
-            throw new Error(`[LocalLLM] ${this.provider} embedding request failed: ${response.status} ${response.statusText}${body ? ` — ${body.slice(0, 200)}` : ""}`);
-        }
-        const json = (await response.json());
-        // Sort by index to guarantee order matches input order
-        const sorted = [...json.data].sort((a, b) => a.index - b.index);
-        return {
-            embeddings: sorted.map((d) => d.embedding),
-            model: json.model ?? this.embeddingModel,
-            totalTokens: json.usage?.total_tokens ?? 0,
-        };
-    }
-    async isAvailable() {
-        try {
-            // Ollama: GET /api/tags lists models
-            // LM Studio: GET /v1/models lists models
-            // OpenAI-compatible: GET /v1/models lists models
-            // Try the most common endpoint first
-            const modelsUrl = this.provider === "ollama"
-                ? `${this.baseUrl.replace(/\/+$/, "")}/api/tags`
-                : `${this.baseUrl.replace(/\/+$/, "")}/v1/models`;
-            const headers = {};
-            if (this.apiKey) {
-                headers.Authorization = `Bearer ${this.apiKey}`;
-            }
-            const response = await fetch(modelsUrl, {
-                method: "GET",
-                headers,
-                signal: AbortSignal.timeout(3000),
-            });
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-}
-// ── Anthropic Direct Adapter ─────────────────────────────────
-// Anthropic has no embedding API. This adapter uses the configured
-// baseUrl for embeddings (which must be a local embedding server)
-// and only uses the Anthropic API for chat (not implemented here).
-class AnthropicDirectAdapter {
-    provider = "anthropic-direct";
-    baseUrl;
-    embeddingModel;
-    embeddingDimensions;
-    maxConcurrency;
-    inner;
-    constructor(config) {
-        const endpoint = resolveEmbeddingEndpoint(config);
-        this.baseUrl =
-            endpoint.baseUrl ?? DEFAULT_BASE_URLS["anthropic-direct"] ?? "";
-        this.embeddingModel = endpoint.model;
-        this.embeddingDimensions = config.embeddingDimensions;
-        this.maxConcurrency = config.maxConcurrency;
-        this.inner = new OpenAiCompatibleAdapter(config, "anthropic-direct (embedding proxy)");
-    }
-    async embed(texts) {
-        return this.inner.embed(texts);
-    }
-    async isAvailable() {
-        return this.inner.isAvailable();
-    }
-}
-// ── Factory ──────────────────────────────────────────────────
-/**
- * Create a LocalLlmAdapter for the given settings.
- * Returns null if no localLlm config is provided.
- */
-export function createLocalLlmAdapter(config) {
-    if (!config)
-        return null;
-    const embeddingEndpoint = resolveEmbeddingEndpoint(config);
-    const effectiveProvider = embeddingEndpoint.provider;
-    switch (effectiveProvider) {
-        case "ollama":
-            return new OpenAiCompatibleAdapter(config, "ollama");
-        case "lm-studio":
-            return new OpenAiCompatibleAdapter(config, "lm-studio");
-        case "openai-compatible":
-            return new OpenAiCompatibleAdapter(config, "openai-compatible");
-        case "anthropic-direct":
-            return new AnthropicDirectAdapter(config);
-        default:
-            return new OpenAiCompatibleAdapter(config, effectiveProvider);
-    }
-}
-/**
- * Create adapter and verify availability, logging to stderr.
- * Returns the adapter (available or not) — callers check isAvailable() as needed.
- */
-export async function createAndVerifyAdapter(config) {
-    const adapter = createLocalLlmAdapter(config);
-    if (!adapter)
-        return null;
-    const available = await adapter.isAvailable();
-    if (available) {
-        process.stderr.write(`[unerr] BYO-LLM: ${adapter.provider} at ${adapter.baseUrl} ✓ (model: ${adapter.embeddingModel})\n`);
-    }
-    else {
-        process.stderr.write(`[unerr] BYO-LLM: ${adapter.provider} at ${adapter.baseUrl} — not reachable (embeddings disabled)\n`);
-    }
-    return adapter;
-}

package/dist/intelligence/local-rule-generator.js

@@ -1,154 +0,0 @@
-/**
- * Sprint L6.2: Local Rule Generator from Conventions
- *
- * Converts detected convention patterns into evaluable rules compatible
- * with the CozoDB `rules` relation and `rule-evaluator.ts`.
- *
- * Each generated rule uses `engine: "structural"` (tree-sitter / naming regex),
- * NEVER LLM-based evaluation. Rules carry `source: "local-convention-detector"`
- * attribution to distinguish from external rules.
- *
- * All logging to stderr. Never touches stdout.
- */
-// ── Naming → Query Mapping ──────────────────────────────────────
-/** Maps naming pattern IDs to tree-sitter query fragments for rule-evaluator.ts. */
-const NAMING_QUERIES = {
-    camelCase: "^[a-z][a-zA-Z0-9]*$",
-    PascalCase: "^[A-Z][a-zA-Z0-9]*$",
-    snake_case: "^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$",
-    SCREAMING_SNAKE: "^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$",
-    "kebab-case": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
-};
-/** Maps entity kinds to glob patterns. */
-const KIND_TO_GLOB = {
-    function: "**/*.{ts,tsx,js,jsx,py,go}",
-    class: "**/*.{ts,tsx,js,jsx,py,java}",
-    interface: "**/*.{ts,tsx}",
-    type: "**/*.{ts,tsx}",
-    method: "**/*.{ts,tsx,js,jsx,py,go,java}",
-    variable: "**/*.{ts,tsx,js,jsx}",
-    component: "**/*.{tsx,jsx}",
-};
-// ── Main Generation Function ────────────────────────────────────
-/**
- * Generate evaluable rules from detected convention patterns.
- *
- * @param conventions - Output from detectLocalConventions()
- * @param repoId - Repository ID for rule scoping
- * @returns CompactRule[] ready for CozoGraphStore.loadRules()
- */
-export function generateLocalRules(conventions, repoId) {
-    const rules = [];
-    let naming = 0;
-    let structural = 0;
-    let importDirection = 0;
-    for (const convention of conventions) {
-        const rule = conventionToRule(convention, repoId);
-        if (rule) {
-            rules.push(rule);
-            switch (convention.kind) {
-                case "naming":
-                    naming++;
-                    break;
-                case "structure":
-                    structural++;
-                    break;
-                case "import_direction":
-                    importDirection++;
-                    break;
-            }
-        }
-    }
-    return {
-        rules,
-        stats: {
-            naming,
-            structural,
-            importDirection,
-            total: rules.length,
-        },
-    };
-}
-// ── Convention → Rule Conversion ────────────────────────────────
-function conventionToRule(convention, repoId) {
-    const ruleKey = `local-rule-${convention.key}`;
-    switch (convention.kind) {
-        case "naming":
-            return namingConventionToRule(convention, ruleKey, repoId);
-        case "structure":
-            return structureConventionToRule(convention, ruleKey, repoId);
-        case "import_direction":
-            return importDirectionConventionToRule(convention, ruleKey, repoId);
-        default:
-            return null;
-    }
-}
-function namingConventionToRule(convention, ruleKey, repoId) {
-    // Extract naming pattern ID from convention key (e.g., "naming-function-camelCase" → "camelCase")
-    const parts = convention.key.split("-");
-    const patternId = parts[parts.length - 1];
-    const entityKind = parts.slice(1, -1).join("-");
-    const query = NAMING_QUERIES[patternId] ?? "";
-    const glob = KIND_TO_GLOB[entityKind] ?? "**/*.{ts,tsx,js,jsx}";
-    return {
-        key: ruleKey,
-        name: convention.name,
-        scope: "repo",
-        severity: "warn",
-        engine: "structural",
-        query,
-        message: `Convention: ${convention.name} (${Math.round(convention.confidence * 100)}% adherence). ${convention.detail}`,
-        file_glob: glob,
-        enabled: true,
-        repo_id: repoId,
-        status: "active",
-        target_kinds: entityKind === "component" ? "function" : entityKind,
-        ast_grep_fix: "",
-        example: "",
-        decay_score: 0,
-        evaluations: 0,
-        overrides: 0,
-    };
-}
-function structureConventionToRule(convention, ruleKey, repoId) {
-    return {
-        key: ruleKey,
-        name: convention.name,
-        scope: "repo",
-        severity: "info",
-        engine: "structural",
-        query: "",
-        message: `Structure convention: ${convention.detail}`,
-        file_glob: "**/*.{ts,tsx,js,jsx}",
-        enabled: true,
-        repo_id: repoId,
-        status: "active",
-        target_kinds: "",
-        ast_grep_fix: "",
-        example: "",
-        decay_score: 0,
-        evaluations: 0,
-        overrides: 0,
-    };
-}
-function importDirectionConventionToRule(convention, ruleKey, repoId) {
-    return {
-        key: ruleKey,
-        name: convention.name,
-        scope: "repo",
-        severity: "warn",
-        engine: "structural",
-        query: "",
-        message: `Import direction convention: ${convention.detail}`,
-        file_glob: "**/*.{ts,tsx,js,jsx}",
-        enabled: true,
-        repo_id: repoId,
-        status: "active",
-        target_kinds: "",
-        ast_grep_fix: "",
-        example: "",
-        decay_score: 0,
-        evaluations: 0,
-        overrides: 0,
-    };
-}

package/dist/intelligence/local-snapshot.js

@@ -1,213 +0,0 @@
-/**
- * Local Snapshot Persistence — Sprint L2.2
- *
- * Saves and loads locally-indexed graphs as msgpack.gz files at
- * `<projectRoot>/.unerr/snapshots/graph.msgpack.gz`. On subsequent boots,
- * loads from snapshot instead of re-indexing. Re-indexes only when
- * source files have changed (mtime-based freshness check).
- *
- * Snapshot format is compatible with SnapshotEnvelope from local-graph.ts,
- * enabling reuse of CozoGraphStore.loadSnapshot() for the load path.
- */
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
-// ── Constants ────────────────────────────────────────────────────
-/** Snapshot file name within the repo's .unerr/snapshots/ directory */
-const SNAPSHOT_FILENAME = "graph.msgpack.gz";
-/** File extensions to check for freshness (must match local-indexer). */
-const SOURCE_EXTENSIONS = new Set([
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".py",
-    ".go",
-    ".java",
-    ".rs",
-    ".c",
-    ".h",
-    ".cpp",
-    ".cc",
-    ".cxx",
-    ".hpp",
-]);
-/** Directories to skip during freshness scan. */
-const EXCLUDED_DIRS = new Set([
-    "node_modules",
-    "dist",
-    "build",
-    "out",
-    ".git",
-    ".hg",
-    ".svn",
-    "coverage",
-    "__pycache__",
-    ".mypy_cache",
-    ".pytest_cache",
-    "vendor",
-    "target",
-    ".next",
-    ".nuxt",
-    ".output",
-    ".unerr",
-    ".cache",
-    ".turbo",
-    ".parcel-cache",
-]);
-/** Path-prefix exclusions (relative to projectRoot). See local-indexer.ts. */
-const EXCLUDED_PATH_PREFIXES = [
-    ".claude/worktrees",
-    ".cursor/worktrees",
-    ".idea/worktrees",
-];
-function isExcludedPath(relPath) {
-    for (const prefix of EXCLUDED_PATH_PREFIXES) {
-        if (relPath === prefix || relPath.startsWith(`${prefix}/`))
-            return true;
-    }
-    return false;
-}
-// ── Public API ───────────────────────────────────────────────────
-/**
- * Generate the snapshot file path for a given project root.
- * Stores within the repo's own .unerr/snapshots/ directory.
- */
-export function snapshotPath(projectRoot) {
-    return join(projectRoot, ".unerr", "snapshots", SNAPSHOT_FILENAME);
-}
-/**
- * Get snapshot metadata (path + existence).
- */
-export function getSnapshotMeta(projectRoot) {
-    const path = snapshotPath(projectRoot);
-    return { path, exists: existsSync(path) };
-}
-/**
- * Determine if the project needs re-indexing.
- *
- * Checks against the persistent DB file mtime first (preferred),
- * falls back to snapshot file mtime for backward compatibility.
- *
- * Returns true if:
- * - Neither persistent DB nor snapshot file exists
- * - Any source file has mtime newer than the reference file
- */
-export function shouldReindex(projectRoot) {
-    // Prefer persistent DB mtime as freshness reference
-    const dbPath = join(projectRoot, ".unerr", "graph.db");
-    const snPath = snapshotPath(projectRoot);
-    let referenceMtime = null;
-    // Check persistent DB first
-    if (existsSync(dbPath)) {
-        try {
-            referenceMtime = statSync(dbPath).mtimeMs;
-        }
-        catch {
-            // fall through
-        }
-    }
-    // Fall back to snapshot
-    if (referenceMtime === null && existsSync(snPath)) {
-        try {
-            referenceMtime = statSync(snPath).mtimeMs;
-        }
-        catch {
-            // fall through
-        }
-    }
-    // No reference — definitely needs indexing
-    if (referenceMtime === null)
-        return true;
-    return hasNewerSource(projectRoot, referenceMtime);
-}
-/**
- * Save a local snapshot to disk.
- *
- * Creates the snapshots directory if needed. Writes a SnapshotEnvelope
- * as gzipped msgpack.
- */
-export async function persistLocalSnapshot(projectRoot, repoId, entities, edges) {
-    const snapshotsDir = join(projectRoot, ".unerr", "snapshots");
-    mkdirSync(snapshotsDir, { recursive: true });
-    const envelope = {
-        version: 1,
-        repoId,
-        orgId: "local",
-        entities,
-        edges,
-        generatedAt: new Date().toISOString(),
-    };
-    const { pack } = await import("msgpackr");
-    const { gzipSync } = await import("node:zlib");
-    const packed = pack(envelope);
-    const compressed = gzipSync(packed);
-    const path = snapshotPath(projectRoot);
-    writeFileSync(path, compressed);
-    return path;
-}
-/**
- * Load a local snapshot from disk into a CozoGraphStore.
- *
- * Returns true if snapshot was loaded, false if no snapshot exists.
- */
-export async function loadLocalSnapshot(projectRoot, graphStore) {
-    const path = snapshotPath(projectRoot);
-    if (!existsSync(path))
-        return false;
-    try {
-        const { unpack } = await import("msgpackr");
-        const { gunzipSync } = await import("node:zlib");
-        const raw = readFileSync(path);
-        const buffer = gunzipSync(raw);
-        const envelope = unpack(buffer);
-        await graphStore.loadSnapshot(envelope);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// ── Internal ─────────────────────────────────────────────────────
-/**
- * Scan project directory for any source file newer than the given mtime.
- * Returns true as soon as one is found (short-circuit for performance).
- */
-function hasNewerSource(projectRoot, snapshotMtime) {
-    return scanDirForNewer(projectRoot, snapshotMtime);
-}
-function scanDirForNewer(dir, threshold) {
-    let entries;
-    try {
-        entries = readdirSync(dir);
-    }
-    catch {
-        return false;
-    }
-    for (const entry of entries) {
-        if (EXCLUDED_DIRS.has(entry))
-            continue;
-        if (entry.startsWith(".") && entry !== ".")
-            continue;
-        const fullPath = join(dir, entry);
-        let stat;
-        try {
-            stat = statSync(fullPath);
-        }
-        catch {
-            continue;
-        }
-        if (stat.isDirectory()) {
-            if (scanDirForNewer(fullPath, threshold))
-                return true;
-        }
-        else if (stat.isFile()) {
-            const ext = fullPath.slice(fullPath.lastIndexOf(".")).toLowerCase();
-            if (SOURCE_EXTENSIONS.has(ext) && stat.mtimeMs > threshold) {
-                return true;
-            }
-        }
-    }
-    return false;
-}

package/dist/intelligence/negative-knowledge.js

@@ -1,103 +0,0 @@
-/**
- * Negative Knowledge — learns from rewinds and reverts.
- *
- * When a rewind occurs (detected from shadow ledger), analyzes what went wrong:
- *   - Entity modified then reverted → the modification pattern is an anti-pattern
- *   - Stores entity key + error description as a correction entry
- *
- * Corrections feed into convention enforcement (H.4) and session context (C.2).
- * No LLM required — pure heuristic analysis from ledger + diff data.
- *
- * Temporal intelligence note: corrections are procedural memory (Section 13.2)
- * with near-permanent decay — only overwritten by demonstrated evolution.
- */
-/**
- * Detect anti-patterns from a rewind event in the ledger.
- *
- * Scans entries before the rewind to find what was modified,
- * then generates correction entries for the reverted changes.
- */
-export function detectAntiPatterns(entries, rewindEntryId) {
-    const rewindIdx = entries.findIndex((e) => e.id === rewindEntryId);
-    if (rewindIdx < 0)
-        return [];
-    const rewindEntry = entries[rewindIdx];
-    const rewindResult = rewindEntry.result_summary;
-    const targetId = rewindResult.rewind_target_id;
-    if (!targetId)
-        return [];
-    const targetIdx = entries.findIndex((e) => e.id === targetId);
-    if (targetIdx < 0)
-        return [];
-    const revertedEntries = entries.slice(targetIdx + 1, rewindIdx);
-    const corrections = [];
-    const seenEntities = new Set();
-    for (const entry of revertedEntries) {
-        if (entry.tool !== "sync_local_diff")
-            continue;
-        const files = extractFiles(entry.args_summary);
-        for (const file of files) {
-            if (seenEntities.has(file))
-                continue;
-            seenEntities.add(file);
-            corrections.push({
-                id: `correction-${rewindEntryId}-${corrections.length}`,
-                entityKey: file,
-                pattern: "modified-then-reverted",
-                reason: `File ${file} was modified and subsequently reverted. The modification approach was incorrect.`,
-                detectedAt: new Date().toISOString(),
-                rewindEntryId,
-                confidence: 0.7,
-            });
-        }
-    }
-    return corrections;
-}
-/**
- * Detect repeated modification patterns that indicate instability.
- * Entity modified 3+ times in rapid succession → likely anti-pattern.
- */
-export function detectInstableEntities(entries, windowMs = 10 * 60 * 1000) {
-    const entityTimestamps = new Map();
-    for (const entry of entries) {
-        if (entry.tool !== "sync_local_diff")
-            continue;
-        const files = extractFiles(entry.args_summary);
-        const ts = new Date(entry.ts).getTime();
-        for (const file of files) {
-            const timestamps = entityTimestamps.get(file) ?? [];
-            timestamps.push(ts);
-            entityTimestamps.set(file, timestamps);
-        }
-    }
-    const corrections = [];
-    for (const [entityKey, timestamps] of entityTimestamps) {
-        if (timestamps.length < 3)
-            continue;
-        timestamps.sort((a, b) => a - b);
-        for (let i = 2; i < timestamps.length; i++) {
-            const window = timestamps[i] - timestamps[i - 2];
-            if (window < windowMs) {
-                corrections.push({
-                    id: `instability-${entityKey}-${i}`,
-                    entityKey,
-                    pattern: "rapid-modification",
-                    reason: `${entityKey} was modified ${timestamps.length} times in rapid succession, suggesting instability.`,
-                    detectedAt: new Date().toISOString(),
-                    rewindEntryId: "",
-                    confidence: 0.5 + Math.min(0.4, timestamps.length * 0.05),
-                });
-                break;
-            }
-        }
-    }
-    return corrections;
-}
-function extractFiles(args) {
-    const files = args.files;
-    if (!Array.isArray(files))
-        return [];
-    return files
-        .map((f) => typeof f === "string" ? f : (f?.path ?? ""))
-        .filter(Boolean);
-}