@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/proxy/shell-strategies/tree-paths.js

@@ -1,144 +0,0 @@
-/**
- * Strategy T5 — tree/find/ls -R path compression.
- *
- * v2 (R7): groups paths by directory and emits compact directory rollups
- * with per-extension counts ("src/components/ (47 files: 12 .tsx, 35 .ts)")
- * instead of head/tail truncation. Targets 70%+ compression vs the previous
- * 42%.
- *
- * The output is still readable by a coding agent — it can ask for a deeper
- * listing on any directory that turns out to matter.
- */
-const COLLAPSE_DIRS = new Set([
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    "out",
-    "__pycache__",
-    ".next",
-    ".nuxt",
-    "target",
-    "vendor",
-    ".tox",
-    ".mypy_cache",
-    ".pytest_cache",
-    ".venv",
-    "venv",
-    "coverage",
-    ".coverage",
-    ".turbo",
-    ".cache",
-]);
-const SMALL_THRESHOLD = 40; // <40 lines: pass through unchanged
-/** Extract a clean path from a tree/find line (drop ascii-tree decorations). */
-function cleanPath(line) {
-    return line.replace(/^[`│├└┌├─\s]+/, "").trim();
-}
-/** Directory portion of a path; "" for top-level files. */
-function dirOf(p) {
-    const i = p.lastIndexOf("/");
-    return i >= 0 ? p.slice(0, i) : "";
-}
-/** Extension key — ".tsx" / ".rs" / "(no-ext)" — for bucket counts. */
-function extOf(p) {
-    const base = p.slice(p.lastIndexOf("/") + 1);
-    const dot = base.lastIndexOf(".");
-    if (dot <= 0 || dot === base.length - 1)
-        return "(no-ext)";
-    return base.slice(dot).toLowerCase();
-}
-/** Top-K extensions in a bucket, formatted "12 .tsx, 35 .ts". */
-function topExt(byExt, k = 4) {
-    const sorted = [...byExt.entries()].sort((a, b) => b[1] - a[1]);
-    const head = sorted.slice(0, k).map(([ext, n]) => `${n} ${ext}`);
-    if (sorted.length > k) {
-        const rest = sorted.slice(k).reduce((s, [, n]) => s + n, 0);
-        head.push(`${rest} other`);
-    }
-    return head.join(", ");
-}
-export function compressTreePaths(raw, _maxDepth, command) {
-    void command;
-    const lines = raw.replace(/\r\n/g, "\n").split("\n");
-    // Small outputs pass through (no benefit, just adds noise)
-    if (lines.length < SMALL_THRESHOLD)
-        return raw;
-    const paths = [];
-    const nonPathLines = [];
-    for (const line of lines) {
-        const cleaned = cleanPath(line);
-        if (!cleaned)
-            continue;
-        if (cleaned.includes("/") && cleaned.length > 1 && !cleaned.includes(" ")) {
-            paths.push(cleaned);
-        }
-        else if (cleaned.length > 0 && nonPathLines.length < 6) {
-            nonPathLines.push(cleaned);
-        }
-    }
-    if (paths.length === 0)
-        return raw;
-    const buckets = new Map();
-    const collapsedBuckets = new Map();
-    for (const p of paths) {
-        let collapsedKey = null;
-        for (const dir of COLLAPSE_DIRS) {
-            if (p.includes(`/${dir}/`) || p.startsWith(`${dir}/`)) {
-                collapsedKey = dir;
-                break;
-            }
-        }
-        if (collapsedKey) {
-            collapsedBuckets.set(collapsedKey, (collapsedBuckets.get(collapsedKey) ?? 0) + 1);
-            continue;
-        }
-        const dir = dirOf(p);
-        const base = p.slice(p.lastIndexOf("/") + 1);
-        let bucket = buckets.get(dir);
-        if (!bucket) {
-            bucket = {
-                files: 0,
-                byExt: new Map(),
-                subdirs: new Set(),
-                samples: [],
-            };
-            buckets.set(dir, bucket);
-        }
-        bucket.files++;
-        const ext = extOf(p);
-        bucket.byExt.set(ext, (bucket.byExt.get(ext) ?? 0) + 1);
-        if (bucket.samples.length < 3)
-            bucket.samples.push(base);
-        const parent = dirOf(dir);
-        const parentBucket = buckets.get(parent);
-        if (parentBucket)
-            parentBucket.subdirs.add(dir);
-    }
-    const sortedDirs = [...buckets.keys()].sort();
-    const out = ["_shell_fmt:tree_paths"];
-    out.push(`(${paths.length} paths across ${sortedDirs.length} dirs; rolled up)`);
-    for (const h of nonPathLines.slice(0, 2))
-        out.push(h);
-    for (const dir of sortedDirs) {
-        const b = buckets.get(dir);
-        if (!b)
-            continue;
-        const label = dir === "" ? "./" : `${dir}/`;
-        const extSummary = topExt(b.byExt);
-        const sample = b.samples.length > 0 && b.files <= 4
-            ? ` — ${b.samples.join(", ")}`
-            : b.files <= 8
-                ? ` — e.g. ${b.samples.join(", ")}`
-                : "";
-        out.push(`${label} (${b.files} files: ${extSummary})${sample}`);
-    }
-    for (const [dir, count] of collapsedBuckets) {
-        out.push(`${dir}/ (${count} entries) [collapsed]`);
-    }
-    for (const t of nonPathLines.slice(-2)) {
-        if (/\bdirector(?:y|ies)\b/i.test(t) || /\bfiles?\b/i.test(t))
-            out.push(t);
-    }
-    return out.join("\n");
-}

package/dist/proxy/shell-strategies/yaml.js

@@ -1,182 +0,0 @@
-/**
- * Strategy T10 — YAML output compression.
- * Collapses large nested blocks, samples long arrays, prunes noisy metadata keys.
- * Handles Kubernetes manifests, Helm values, docker-compose, and generic YAML.
- */
-/** Kubernetes metadata keys that are typically noise for LLM consumption. */
-const DROP_KEYS = new Set([
-    "managedFields",
-    "resourceVersion",
-    "selfLink",
-    "uid",
-    "creationTimestamp",
-    "generation",
-    "ownerReferences",
-    "finalizers",
-    "kubectl.kubernetes.io/last-applied-configuration",
-    "deployment.kubernetes.io/revision",
-    "control-plane.alpha.kubernetes.io/leader",
-]);
-const VALUE_MAX = 200;
-/** Detect the indent unit (number of spaces per level) from the first indented line. */
-function detectIndentUnit(lines) {
-    for (const line of lines) {
-        const m = /^( +)\S/.exec(line);
-        if (m)
-            return m[1]?.length ?? 0;
-    }
-    return 2;
-}
-/** Get the indentation level (in spaces) of a line. */
-function indentOf(line) {
-    const m = /^( *)/.exec(line);
-    return m ? (m[1]?.length ?? 0) : 0;
-}
-/**
- * Compress YAML output for token efficiency.
- *
- * Strategy:
- * 1. Drop noisy k8s metadata keys and their sub-blocks
- * 2. Collapse large nested blocks (>15 child lines) into summaries
- * 3. Sample long YAML arrays (keep first 3, last 1, collapse middle)
- * 4. Truncate long scalar values
- * 5. Clip overall output if still too large
- */
-export function compressYaml(raw, command) {
-    void command;
-    const lines = raw.split("\n");
-    if (lines.length <= 40) {
-        return raw;
-    }
-    const indentUnit = detectIndentUnit(lines);
-    const kept = [];
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        const trimmed = line.trimStart();
-        // Skip empty lines — keep them
-        if (trimmed === "" || trimmed === "---" || trimmed === "...") {
-            kept.push(line);
-            i++;
-            continue;
-        }
-        // Check for key: pattern (not array items)
-        const keyMatch = /^(\s*)([\w][\w./-]*):\s*(.*)$/.exec(line);
-        if (keyMatch) {
-            const [, indent, key, value] = keyMatch;
-            const indentLen = indent?.length ?? 0;
-            // Drop noisy keys and their entire sub-block
-            if (DROP_KEYS.has(key)) {
-                i++;
-                // Skip child lines
-                while (i < lines.length) {
-                    const nextLine = lines[i];
-                    if (nextLine.trim() === "") {
-                        i++;
-                        break;
-                    }
-                    if (indentOf(nextLine) <= indentLen && nextLine.trim())
-                        break;
-                    i++;
-                }
-                continue;
-            }
-            // Count child lines for this key
-            if (!value?.trim()) {
-                const childIndent = indentLen + indentUnit;
-                let childCount = 0;
-                let j = i + 1;
-                while (j < lines.length) {
-                    const nextLine = lines[j];
-                    if (nextLine.trim() === "") {
-                        j++;
-                        continue;
-                    }
-                    if (indentOf(nextLine) < childIndent)
-                        break;
-                    childCount++;
-                    j++;
-                }
-                // Collapse large sub-blocks
-                if (childCount > 15) {
-                    kept.push(line);
-                    // Keep first 3 child lines as preview
-                    let preview = 0;
-                    let k = i + 1;
-                    while (k < j && preview < 3) {
-                        if (lines[k]?.trim()) {
-                            kept.push(lines[k]);
-                            preview++;
-                        }
-                        k++;
-                    }
-                    kept.push(`${" ".repeat(childIndent)}# ... ${childCount - 3} more lines`);
-                    i = j;
-                    continue;
-                }
-            }
-            // Truncate long scalar values
-            if (value && value.length > VALUE_MAX) {
-                kept.push(`${indent}${key}: ${value.slice(0, 100)}...(${value.length} chars)`);
-                i++;
-                continue;
-            }
-        }
-        // Array items: detect long arrays and sample them
-        if (/^\s*-\s/.test(line)) {
-            const arrayIndent = indentOf(line);
-            const arrayItems = [];
-            // Collect all array items at this indent level
-            let j = i;
-            while (j < lines.length) {
-                const cur = lines[j];
-                if (cur.trim() === "") {
-                    j++;
-                    continue;
-                }
-                if (indentOf(cur) < arrayIndent)
-                    break;
-                if (indentOf(cur) === arrayIndent && /^\s*-\s/.test(cur)) {
-                    const itemStart = j;
-                    j++;
-                    // Collect sub-lines of this array item
-                    while (j < lines.length) {
-                        const sub = lines[j];
-                        if (sub.trim() === "") {
-                            j++;
-                            continue;
-                        }
-                        if (indentOf(sub) <= arrayIndent)
-                            break;
-                        j++;
-                    }
-                    arrayItems.push({ start: itemStart, end: j });
-                }
-                else {
-                    break;
-                }
-            }
-            if (arrayItems.length > 8) {
-                // Sample: first 3, last 1, collapse middle
-                for (const item of arrayItems.slice(0, 3)) {
-                    for (let k = item.start; k < item.end; k++)
-                        kept.push(lines[k]);
-                }
-                kept.push(`${" ".repeat(arrayIndent)}# ... ${arrayItems.length - 4} more items`);
-                const lastItem = arrayItems[arrayItems.length - 1];
-                for (let k = lastItem.start; k < lastItem.end; k++)
-                    kept.push(lines[k]);
-                i = j;
-                continue;
-            }
-        }
-        // Default: keep the line
-        kept.push(line);
-        i++;
-    }
-    const body = kept.join("\n");
-    const clipped = body.length > 12_000
-        ? `${body.slice(0, 8000)}\n# ...yaml_omitted...\n${body.slice(-3000)}`
-        : body;
-    return `_shell_fmt:yaml\n${clipped}`;
-}

package/dist/proxy/shell-tee.js

@@ -1,111 +0,0 @@
-/**
- * Shell output tee — persists full raw output to disk when compression is significant.
- * Enables recovery of full context when compressed output is insufficient.
- */
-import { mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
-const MAX_TEE_FILES = 50;
-const MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h
-function commandSlug(cmd) {
-    return cmd
-        .trim()
-        .split(/\s+/)
-        .slice(0, 2)
-        .join("-")
-        .replace(/[^a-zA-Z0-9_-]/g, "_")
-        .slice(0, 40);
-}
-/**
- * Writes full shell output to `.unerr/tee/<ts>-<slug>.txt` when:
- * - compression ratio > 30%
- * - raw size > 1KB
- *
- * Returns null if thresholds are not met or write fails.
- */
-export function teeShellOutput(cwd, command, raw, compressed) {
-    const ratio = 1 - compressed.length / raw.length;
-    if (ratio < 0.3 || raw.length < 1024)
-        return null;
-    const teeDir = join(cwd, ".unerr", "tee");
-    try {
-        mkdirSync(teeDir, { recursive: true });
-    }
-    catch {
-        // already exists
-    }
-    const slug = commandSlug(command);
-    const ts = Date.now();
-    const filename = `${ts}-${slug}.txt`;
-    const filePath = join(teeDir, filename);
-    const header = [
-        "# unerr tee — full shell output",
-        `# command: ${command}`,
-        `# captured: ${new Date(ts).toISOString()}`,
-        `# raw_bytes: ${raw.length}  compressed_bytes: ${compressed.length}  ratio: ${(ratio * 100).toFixed(1)}%`,
-        "# ---",
-        "",
-    ].join("\n");
-    const content = header + raw;
-    try {
-        writeFileSync(filePath, content, "utf8");
-    }
-    catch {
-        return null;
-    }
-    cleanupOldTees(teeDir);
-    return { filePath, sizeBytes: content.length };
-}
-/**
- * Removes tee files older than `maxAgeMs` and keeps at most `MAX_TEE_FILES`.
- * Returns the number of files deleted.
- */
-export function cleanupOldTees(teeDir, maxAgeMs = MAX_AGE_MS) {
-    let deleted = 0;
-    let entries = [];
-    try {
-        entries = readdirSync(teeDir)
-            .filter((f) => f.endsWith(".txt"))
-            .map((name) => {
-            const p = join(teeDir, name);
-            try {
-                const { mtimeMs } = statSync(p);
-                return { name, mtime: mtimeMs, path: p };
-            }
-            catch {
-                return { name, mtime: 0, path: p };
-            }
-        });
-    }
-    catch {
-        return 0;
-    }
-    const now = Date.now();
-    // Delete files older than maxAgeMs
-    for (const e of entries) {
-        if (now - e.mtime > maxAgeMs) {
-            try {
-                unlinkSync(e.path);
-                deleted++;
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-    // Keep at most MAX_TEE_FILES (newest first)
-    const remaining = entries
-        .filter((e) => now - e.mtime <= maxAgeMs)
-        .sort((a, b) => b.mtime - a.mtime);
-    if (remaining.length > MAX_TEE_FILES) {
-        for (const e of remaining.slice(MAX_TEE_FILES)) {
-            try {
-                unlinkSync(e.path);
-                deleted++;
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-    return deleted;
-}

package/dist/proxy/signal-dedup.js

@@ -1,171 +0,0 @@
-/**
- * Signal Emission Dedup — gates `ur|<tag>` signal lines so the same fact is not
- * re-emitted on every tool call within a session.
- *
- * Why: `buildSignalPrefix` (response-envelope.ts) and `applyWireCap`
- * (wire-cap.ts) inject anti-drift signals into MCP tool response bodies. Many
- * of these — risk scores, project facts, hints — are *sticky knowledge*: true
- * for the whole session and never changing. Re-emitting them on every call
- * drowns the model in fluff and inflates token cost.
- *
- * Three signal classes:
- *   1. Critical / state-change (always emit): hlt, dft, hth — circuit-break,
- *      drift, session health. Re-emit because state has actually changed.
- *   2. Sticky knowledge (emit once or on content change): rsk, fct, hnt, hst,
- *      cnv, pro, sem, epi — surface once per (tag, entity), then again only
- *      if the content actually changes.
- *   3. Hard once-per-session: wrn — anti-pattern warnings stay relevant the
- *      whole session but the agent only needs to be told once.
- *   4. Drop entirely: ctx — "context already delivered" is itself noise; the
- *      session-dedup layer already gates the underlying context.
- *
- * Dedup key: `${tag}:${entityKey ?? "global"}:${valueHash}` for `on_change`
- * policy, `${tag}:${entityKey ?? "global"}` for `once_per_session` / `always`
- * (always still records but never blocks).
- *
- * Process-lifetime in-memory only (matches session-dedup.ts pattern). Bounded
- * to MAX_TRACKED to prevent unbounded growth in long-running daemons.
- */
-const MAX_TRACKED = 5000;
-/**
- * Default policy by 3-char signal tag. See ur|<tag> legend in
- * response-envelope.ts (SIGNAL_PREFIX_LEGEND).
- */
-export const DEFAULT_POLICY = {
-    hlt: "always",
-    dft: "always",
-    hth: "always",
-    rsk: "on_change",
-    fct: "on_change",
-    // `wrn` was once_per_session — that silenced ALL warnings after the first
-    // `ur|wrn No dependencies` line, including content-distinct negative-fact
-    // warnings ("Never mock CozoDB...", "anti-pattern in hooks...") that target
-    // a different entity. on_change already suppresses *identical* (tag, scope,
-    // content) repeats, which is the only thing once_per_session protected
-    // against. Different scope or different content = genuinely new warning,
-    // surface it.
-    wrn: "on_change",
-    hnt: "on_change",
-    hst: "on_change",
-    cnv: "on_change",
-    pro: "on_change",
-    sem: "on_change",
-    epi: "on_change",
-    ctx: "drop",
-};
-/**
- * djb2 — fast non-cryptographic hash for content fingerprinting.
- * Good enough to detect "same risk message as last time".
- */
-function hash(s) {
-    let h = 5381;
-    for (let i = 0; i < s.length; i++) {
-        h = ((h << 5) + h) ^ s.charCodeAt(i);
-    }
-    return (h >>> 0).toString(36);
-}
-/**
- * N6 — per-tag session emission cap. Low-priority advisory tags (hint,
- * fact, convention, episodic) are noisy when each new entity legitimately
- * produces a different message — `on_change` lets them all through. The cap
- * adds a session-level ceiling: after N emissions of the same tag in this
- * session, further emissions are dropped regardless of content.
- *
- * Critical tags (hlt/dft/rsk/hth/wrn/hst) are NOT capped — those are
- * load-bearing and must always reach the agent.
- */
-const TAG_SESSION_CAP = {
-    hnt: 5,
-    fct: 4,
-    cnv: 4,
-    pro: 4,
-    sem: 4,
-    epi: 4,
-};
-export function createSignalDedup(policyOverride = {}) {
-    const seen = new Map();
-    const policy = { ...DEFAULT_POLICY, ...policyOverride };
-    const tagCounts = new Map();
-    function evictIfNeeded() {
-        if (seen.size <= MAX_TRACKED)
-            return;
-        const target = Math.floor(MAX_TRACKED * 0.2);
-        const iter = seen.keys();
-        let removed = 0;
-        while (removed < target) {
-            const r = iter.next();
-            if (r.done)
-                break;
-            seen.delete(r.value);
-            removed++;
-        }
-    }
-    function shouldEmit(tag, entityKey, content) {
-        const p = policy[tag] ?? "on_change";
-        if (p === "drop")
-            return false;
-        if (p === "always")
-            return true;
-        // N6 — session-level cap for advisory tags
-        const cap = TAG_SESSION_CAP[tag];
-        if (cap !== undefined && (tagCounts.get(tag) ?? 0) >= cap) {
-            return false;
-        }
-        const k = `${tag}:${entityKey ?? "global"}`;
-        const entry = seen.get(k);
-        const contentHash = hash(content);
-        if (!entry) {
-            seen.set(k, { lastHash: contentHash, firstEmittedAt: Date.now() });
-            evictIfNeeded();
-            tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
-            return true;
-        }
-        if (p === "once_per_session") {
-            return false;
-        }
-        // on_change — emit only if content actually changed.
-        if (entry.lastHash !== contentHash) {
-            entry.lastHash = contentHash;
-            tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
-            return true;
-        }
-        return false;
-    }
-    function wouldEmit(tag, entityKey, content) {
-        const p = policy[tag] ?? "on_change";
-        if (p === "drop")
-            return false;
-        if (p === "always")
-            return true;
-        // N6 — session-cap check
-        const cap = TAG_SESSION_CAP[tag];
-        if (cap !== undefined && (tagCounts.get(tag) ?? 0) >= cap)
-            return false;
-        const k = `${tag}:${entityKey ?? "global"}`;
-        const entry = seen.get(k);
-        if (!entry)
-            return true;
-        if (p === "once_per_session")
-            return false;
-        return entry.lastHash !== hash(content);
-    }
-    function reset() {
-        seen.clear();
-        tagCounts.clear();
-    }
-    function size() {
-        return seen.size;
-    }
-    return { shouldEmit, wouldEmit, reset, size };
-}
-/** Module-level singleton — most callers share one process-wide table. */
-let _singleton = null;
-export function getSignalDedup() {
-    if (!_singleton)
-        _singleton = createSignalDedup();
-    return _singleton;
-}
-/** Test helper — clears the singleton between cases. */
-export function resetSignalDedupSingleton() {
-    _singleton = null;
-}