@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/proxy/shell-monitor-map.js

@@ -0,0 +1,18 @@
+/**
+ * Map shell classifier categories → compression quality monitor content types (FE-F.7).
+ */
+const MAP = {
+    tabular: "shell_tabular",
+    structured: "shell_structured",
+    log_text: "shell_log_text",
+    diff: "shell_diff",
+    tree_paths: "shell_tree_paths",
+    key_value: "shell_key_value",
+    error_diagnostic: "shell_error_diagnostic",
+    test_results: "shell_test_results",
+    progress_streaming: "shell_progress_streaming",
+    yaml: "shell_yaml",
+};
+export function shellCategoryToContentType(category) {
+    return MAP[category];
+}

package/dist/proxy/shell-stats.js

@@ -0,0 +1,54 @@
+/**
+ * Layer 6 Sprint FE-F — persist approximate shell compression savings for `unerr status`.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/** Shared token estimate (~chars/4) for shell I/O and quality ratios. */
+export function estimateRoughTokens(s) {
+    return Math.max(1, Math.ceil(s.length / 4));
+}
+export function recordShellCompressionEvent(cwd, category, original, compressed) {
+    try {
+        const dir = join(cwd, ".unerr", "state");
+        mkdirSync(dir, { recursive: true });
+        const path = join(dir, "shell_compression_stats.json");
+        const origT = estimateRoughTokens(original);
+        const outT = estimateRoughTokens(compressed);
+        const saved = Math.max(0, origT - outT);
+        let agg = {
+            totalEvents: 0,
+            tokensSavedApprox: 0,
+            byCategory: {},
+            updatedAt: new Date().toISOString(),
+        };
+        if (existsSync(path)) {
+            agg = {
+                ...agg,
+                ...JSON.parse(readFileSync(path, "utf-8")),
+            };
+        }
+        agg.totalEvents++;
+        agg.tokensSavedApprox += saved;
+        const prev = agg.byCategory[category] ?? { events: 0, savedApprox: 0 };
+        agg.byCategory[category] = {
+            events: prev.events + 1,
+            savedApprox: prev.savedApprox + saved,
+        };
+        agg.updatedAt = new Date().toISOString();
+        writeFileSync(path, JSON.stringify(agg));
+    }
+    catch {
+        /* ignore */
+    }
+}
+export function readShellCompressionAggregate(cwd) {
+    try {
+        const path = join(cwd, ".unerr", "state", "shell_compression_stats.json");
+        if (!existsSync(path))
+            return null;
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,215 @@
+/**
+ * R4 — Cloud parsers (AWS, kubectl, docker).
+ *
+ * Cloud CLI output is JSON-heavy and noise-heavy: timestamps, RequestIds,
+ * ETags, ARN suffixes, paging tokens. A coding agent rarely needs any of
+ * those; it needs the shape (count, IDs, statuses).
+ *
+ * This module specializes common AWS / kubectl / docker outputs and emits
+ * compact summaries. It's invoked from shell-compressor for matching
+ * commands BEFORE the generic `structured` / `tabular` strategies.
+ *
+ * Each parser is conservative: if shape doesn't match, returns null and the
+ * caller falls back to the generic strategy.
+ */
+function tryParseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function compactArn(arn) {
+    // arn:aws:iam::123456789012:role/MyRole → arn:…:role/MyRole
+    return arn.replace(/^arn:[^:]*:[^:]*:[^:]*:[^:]*:/, "arn:…:");
+}
+function fmtCount(n, singular, plural) {
+    return `${n} ${n === 1 ? singular : (plural ?? `${singular}s`)}`;
+}
+// ─── aws ec2 describe-instances ────────────────────────────────────────────
+function parseAwsEc2(raw) {
+    const data = tryParseJson(raw);
+    if (!data || !Array.isArray(data.Reservations))
+        return null;
+    const rows = [];
+    let count = 0;
+    for (const r of data.Reservations) {
+        const instances = r.Instances ?? [];
+        for (const inst of instances) {
+            count++;
+            const id = inst.InstanceId ?? "?";
+            const state = inst.State?.Name ??
+                "?";
+            const type = inst.InstanceType ?? "?";
+            const ip = inst.PrivateIpAddress ?? "—";
+            const az = inst.Placement?.AvailabilityZone ?? "?";
+            const tags = inst.Tags ?? [];
+            const name = tags.find((t) => t.Key === "Name")?.Value ?? "";
+            rows.push(`${id}  ${state.padEnd(10)} ${type.toString().padEnd(12)} ${ip.toString().padEnd(15)} ${az}  ${name}`);
+        }
+    }
+    if (count === 0)
+        return "_shell_fmt:cloud[aws-ec2]\n0 instances";
+    return `_shell_fmt:cloud[aws-ec2]\n${fmtCount(count, "instance")}\nid                   state      type         ip              az  name\n${rows.join("\n")}`;
+}
+// ─── aws s3 ls (bucket listing) ────────────────────────────────────────────
+function parseAwsS3Ls(raw) {
+    const lines = raw.split("\n").filter((l) => l.trim());
+    if (lines.length === 0)
+        return null;
+    // s3 ls bucket listing: "2024-01-15 10:23:45         1234 file.txt"
+    // bucket listing:       "2024-01-15 10:23:45 my-bucket"
+    let files = 0;
+    let bytes = 0;
+    const samples = [];
+    for (const line of lines) {
+        const m = line.match(/^\s*\S+\s+\S+\s+(\d+)\s+(.+)$/);
+        if (m?.[1] && m[2]) {
+            files++;
+            bytes += Number.parseInt(m[1], 10);
+            if (samples.length < 5)
+                samples.push(m[2]);
+        }
+        else if (/^\s*\S+\s+\S+\s+\S+$/.test(line)) {
+            // bucket listing — not the size form
+            files++;
+            if (samples.length < 5)
+                samples.push(line.trim().split(/\s+/).pop() ?? "");
+        }
+    }
+    if (files === 0)
+        return null;
+    const sizeStr = bytes > 1024 * 1024 * 1024
+        ? `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`
+        : bytes > 1024 * 1024
+            ? `${(bytes / 1024 / 1024).toFixed(2)} MB`
+            : `${(bytes / 1024).toFixed(1)} KB`;
+    return `_shell_fmt:cloud[aws-s3]\n${fmtCount(files, "object")}${bytes > 0 ? `, ${sizeStr}` : ""}\nsamples: ${samples.join(", ")}`;
+}
+// ─── aws iam list-users / list-roles ───────────────────────────────────────
+function parseAwsIam(raw) {
+    const data = tryParseJson(raw);
+    if (!data)
+        return null;
+    for (const key of ["Users", "Roles", "Policies", "Groups"]) {
+        const arr = data[key];
+        if (Array.isArray(arr)) {
+            const rows = arr.slice(0, 25).map((item) => {
+                const name = item[`${key.slice(0, -1)}Name`] ??
+                    item.Name ??
+                    item.PolicyName ??
+                    "?";
+                const arn = item.Arn ?? item[`${key.slice(0, -1)}Arn`] ?? "";
+                return `${name}  ${typeof arn === "string" ? compactArn(arn) : ""}`;
+            });
+            const more = arr.length > 25 ? `\n… ${arr.length - 25} more` : "";
+            return `_shell_fmt:cloud[aws-iam]\n${fmtCount(arr.length, key.slice(0, -1).toLowerCase())}\n${rows.join("\n")}${more}`;
+        }
+    }
+    return null;
+}
+// ─── aws lambda list-functions / invoke ────────────────────────────────────
+function parseAwsLambda(raw) {
+    const data = tryParseJson(raw);
+    if (!data)
+        return null;
+    if (Array.isArray(data.Functions)) {
+        const fns = data.Functions;
+        const rows = fns
+            .slice(0, 20)
+            .map((f) => `${f.FunctionName}  ${f.Runtime}  ${f.LastModified ?? ""}`);
+        const more = fns.length > 20 ? `\n… ${fns.length - 20} more` : "";
+        return `_shell_fmt:cloud[aws-lambda]\n${fmtCount(fns.length, "function")}\n${rows.join("\n")}${more}`;
+    }
+    if (data.StatusCode !== undefined) {
+        return `_shell_fmt:cloud[aws-lambda-invoke]\nstatus=${data.StatusCode}${data.FunctionError ? ` error=${data.FunctionError}` : " ok"}`;
+    }
+    return null;
+}
+// ─── aws cloudformation describe-stacks ────────────────────────────────────
+function parseAwsCfn(raw) {
+    const data = tryParseJson(raw);
+    if (!data || !Array.isArray(data.Stacks))
+        return null;
+    const stacks = data.Stacks;
+    const rows = stacks.map((s) => `${s.StackName}  ${s.StackStatus}  ${s.LastUpdatedTime ?? s.CreationTime ?? ""}`);
+    return `_shell_fmt:cloud[aws-cfn]\n${fmtCount(stacks.length, "stack")}\n${rows.join("\n")}`;
+}
+// ─── kubectl get / describe / logs ─────────────────────────────────────────
+function parseKubectlGet(raw, command) {
+    // JSON form
+    const data = tryParseJson(raw);
+    if (data && Array.isArray(data.items)) {
+        const items = data.items;
+        const kind = data.kind ?? "items";
+        const rows = items.slice(0, 30).map((it) => {
+            const meta = it.metadata ?? {};
+            const status = it.status ?? {};
+            return `${meta.namespace ?? "—"}/${meta.name}  ${(status.phase ?? status.conditions) ? "ok" : "?"}`;
+        });
+        const more = items.length > 30 ? `\n… ${items.length - 30} more` : "";
+        return `_shell_fmt:cloud[kubectl-get]\n${fmtCount(items.length, "resource")} (${kind})\n${rows.join("\n")}${more}`;
+    }
+    // Table form (default kubectl output)
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const header = lines[0];
+    if (header && /^\s*NAME\b/i.test(header)) {
+        const dataLines = lines.slice(1);
+        if (dataLines.length > 40) {
+            void command;
+            return `_shell_fmt:cloud[kubectl-get]\n${fmtCount(dataLines.length, "row")}\n${header}\n${dataLines.slice(0, 30).join("\n")}\n… ${dataLines.length - 30} more`;
+        }
+    }
+    return null;
+}
+function parseKubectlDescribe(raw) {
+    // describe is a nested K:V mash. Strip Events: section (verbose) and managed-fields.
+    if (!/^\s*(Name:|Namespace:|Kind:)/m.test(raw))
+        return null;
+    const stripped = raw
+        .replace(/^Events:[\s\S]*$/m, "Events: (suppressed)")
+        .replace(/^\s+manager:.+$/gm, "")
+        .replace(/^\s+managedFields:[\s\S]*?(?=^\S)/gm, "")
+        .replace(/^\s+resourceVersion:.+$/gm, "")
+        .replace(/^\s+uid:.+$/gm, "")
+        .replace(/^\s+creationTimestamp:.+$/gm, "")
+        .replace(/\n{3,}/g, "\n\n");
+    return `_shell_fmt:cloud[kubectl-describe]\n${stripped.trim()}`;
+}
+// ─── docker inspect / ps ───────────────────────────────────────────────────
+function parseDockerInspect(raw) {
+    const data = tryParseJson(raw);
+    if (!Array.isArray(data) || data.length === 0)
+        return null;
+    const rows = data.map((c) => {
+        const id = typeof c.Id === "string"
+            ? c.Id.slice(0, 12)
+            : (c.Id ?? "?");
+        const state = c.State ?? {};
+        const cfg = c.Config ?? {};
+        return `${id}  ${state.Status ?? "?"}  ${cfg.Image ?? "?"}  ${c.Name ?? ""}`;
+    });
+    return `_shell_fmt:cloud[docker-inspect]\n${fmtCount(rows.length, "container")}\n${rows.join("\n")}`;
+}
+// ─── dispatch ───────────────────────────────────────────────────────────────
+export function tryCompressCloud(raw, command) {
+    const cmd = command.trim();
+    if (cmd.startsWith("aws ec2"))
+        return parseAwsEc2(raw);
+    if (cmd.startsWith("aws s3"))
+        return parseAwsS3Ls(raw);
+    if (cmd.startsWith("aws iam"))
+        return parseAwsIam(raw);
+    if (cmd.startsWith("aws lambda"))
+        return parseAwsLambda(raw);
+    if (cmd.startsWith("aws cloudformation"))
+        return parseAwsCfn(raw);
+    if (/^kubectl\s+get\b/.test(cmd))
+        return parseKubectlGet(raw, cmd);
+    if (/^kubectl\s+describe\b/.test(cmd))
+        return parseKubectlDescribe(raw);
+    if (/^docker\s+inspect\b/.test(cmd))
+        return parseDockerInspect(raw);
+    return null;
+}

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

@@ -0,0 +1,159 @@
+/**
+ * Strategy T4 — tiered git/unified diff compression + optional graph risk hints.
+ * Tiers: stat-only (>5000 lines), hunk-headers (>1000), full (≤1000).
+ * Lock files and generated files are collapsed in all tiers.
+ */
+const LOCK_RE = /package-lock\.json|pnpm-lock\.yaml|yarn\.lock|Cargo\.lock|Gemfile\.lock|poetry\.lock|composer\.lock/;
+const GENERATED_RE = /\.(generated|min|bundle)\.(ts|js|css|map)$|^dist\/|^build\/|^\.next\//;
+function parseDiffFiles(lines) {
+    const files = [];
+    let current = null;
+    for (const line of lines) {
+        if (line.startsWith("diff --git")) {
+            if (current)
+                files.push(current);
+            const m = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
+            const path = m?.[2] ?? "";
+            current = {
+                path,
+                additions: 0,
+                deletions: 0,
+                hunkHeaders: [],
+                isLockFile: LOCK_RE.test(path),
+                isGenerated: GENERATED_RE.test(path),
+            };
+            continue;
+        }
+        if (!current)
+            continue;
+        if (line.startsWith("@@")) {
+            current.hunkHeaders.push(line);
+        }
+        else if (line.startsWith("+") && !line.startsWith("+++")) {
+            current.additions++;
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            current.deletions++;
+        }
+    }
+    if (current)
+        files.push(current);
+    return files;
+}
+function buildHeader(totalFiles, totalAdd, totalDel) {
+    return `_shell_diff:files=${totalFiles},+${totalAdd}/-${totalDel}`;
+}
+function fileLabel(f) {
+    if (f.isLockFile)
+        return `${f.path} (lock file, +${f.additions} -${f.deletions}) [collapsed]`;
+    if (f.isGenerated)
+        return `${f.path} (generated, +${f.additions} -${f.deletions}) [collapsed]`;
+    return "";
+}
+function riskSuffix(f, risks) {
+    if (!risks)
+        return "";
+    for (const [name, r] of risks) {
+        if (f.path.includes(name) &&
+            (r.risk_level === "high" || r.risk_level === "critical" || r.fan_in > 5)) {
+            return ` [${r.risk_level.toUpperCase()}: ${name}, ${r.fan_in} callers]`;
+        }
+    }
+    return "";
+}
+function emitStatOnly(header, files, risks) {
+    const parts = [header];
+    for (const f of files) {
+        const label = fileLabel(f);
+        if (label) {
+            parts.push(`  ${label}`);
+            continue;
+        }
+        const suffix = riskSuffix(f, risks);
+        parts.push(`  ${f.path} | +${f.additions} -${f.deletions}${suffix}`);
+    }
+    return parts.join("\n");
+}
+function emitHunkHeaders(header, files, risks) {
+    const parts = [header];
+    for (const f of files) {
+        const label = fileLabel(f);
+        if (label) {
+            parts.push(`  ${label}`);
+            continue;
+        }
+        const suffix = riskSuffix(f, risks);
+        parts.push(`--- ${f.path} (+${f.additions} -${f.deletions})${suffix}`);
+        for (const hh of f.hunkHeaders) {
+            parts.push(hh);
+        }
+    }
+    return parts.join("\n");
+}
+function emitFull(header, lines, files, risks) {
+    const collapsedPaths = new Set(files.filter((f) => f.isLockFile || f.isGenerated).map((f) => f.path));
+    const parts = [header];
+    let inCollapsedFile = false;
+    const riskNames = risks
+        ? [...risks.entries()]
+            .filter(([, r]) => r.risk_level === "high" ||
+            r.risk_level === "critical" ||
+            r.fan_in > 5)
+            .map(([k]) => k)
+        : [];
+    for (const line of lines) {
+        if (line.startsWith("diff --git")) {
+            const m = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
+            const path = m?.[2] ?? "";
+            if (collapsedPaths.has(path)) {
+                inCollapsedFile = true;
+                const f = files.find((df) => df.path === path);
+                if (f)
+                    parts.push(`${fileLabel(f)}`);
+                continue;
+            }
+            inCollapsedFile = false;
+        }
+        if (inCollapsedFile)
+            continue;
+        if (riskNames.length > 0) {
+            let annotated = false;
+            for (const name of riskNames) {
+                if (line.includes(name)) {
+                    const r = risks?.get(name);
+                    const tag = r
+                        ? `[HIGH-RISK:${name} callers=${r.fan_in} risk=${r.risk_level}]`
+                        : `[HIGH-RISK:${name}]`;
+                    parts.push(`${tag} ${line}`);
+                    annotated = true;
+                    break;
+                }
+            }
+            if (annotated)
+                continue;
+        }
+        parts.push(line);
+    }
+    let body = parts.join("\n");
+    if (body.length > 14_000) {
+        body = `${body.slice(0, 6000)}\n…diff_mid_omitted…\n${body.slice(-5500)}`;
+    }
+    return body;
+}
+export function compressDiff(raw, risks, command) {
+    void command;
+    const lines = raw.split("\n");
+    const diffFiles = parseDiffFiles(lines);
+    const totalLines = lines.length;
+    const totalFiles = diffFiles.length;
+    const totalAdd = diffFiles.reduce((s, f) => s + f.additions, 0);
+    const totalDel = diffFiles.reduce((s, f) => s + f.deletions, 0);
+    const header = buildHeader(totalFiles, totalAdd, totalDel);
+    if (totalLines > 5000 || totalFiles > 20) {
+        return emitStatOnly(header, diffFiles, risks);
+    }
+    if (totalLines > 1000) {
+        return emitHunkHeaders(header, diffFiles, risks);
+    }
+    return emitFull(header, lines, diffFiles, risks);
+}