@unerr-ai/unerr 0.0.1 → 0.1.1

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

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

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

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

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