opencode-slim-output 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mateo Cerri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,89 @@
-# Temporary Holding Version
+# opencode-slim-output
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An OpenCode plugin that shrinks noisy tool output before it reaches the
+model: external stack frames collapse to a counted line, absolute paths
+become relative to the working directory, repeated lines get folded. No
+LLM, no binaries, near-zero latency.
+
+It sits next to [snip](https://github.com/edouard-claude/snip), which
+summarizes per tool for `bash`, and
+[openslimedit](https://github.com/ASidorenkoCode/openslimedit), which
+compresses tool definitions. Neither prunes stack traces across languages
+on `bash`, `grep`, `glob` and `read`, which is the gap this one fills.
+
+A Python traceback before (11 lines, 3 from your code):
+
+```
+Traceback (most recent call last):
+  File "/home/you/proj/app/service.py", line 42, in run
+    handle()
+  File "/home/you/proj/.venv/lib/python3.12/site-packages/requests/api.py", line 123, in handle
+    return go()
+  File "/home/you/proj/.venv/lib/python3.12/site-packages/urllib3/connection.py", line 99, in go
+    sock.connect()
+  File "/usr/lib/python3.12/socket.py", line 456, in connect
+    self._real_connect()
+ConnectionError: boom
+```
+
+After:
+
+```
+Traceback (most recent call last):
+  File "./app/service.py", line 42, in run
+    handle()
+... +3 frames omitted (site-packages/stdlib)
+ConnectionError: boom
+```
+
+Your frames and the error survive. The stdlib plumbing does not.
+
+Collapsing is conservative by design: a line folds only when three signals
+agree. The command gate runs each detector where its noise is expected
+(`pytest` and `python` for Python frames, `dotnet` for .NET, `jest` and
+`tsc` for JS, and so on). The anchor requires a wrapper proving a real
+stack is present (`Traceback (most recent call last):`,
+`NullReferenceException`, `FAIL`, `panicked`, …), so prose that merely
+mentions a file is left alone. And the frame shape must match fully (`File
+"…", line N`, `at Ns.Type.Method(…)`, `path/to/file.go:123`, …) in a run
+of at least `minFrames`. Anything else passes through untouched; unknown
+frames are kept, and only known-external paths (`site-packages`,
+`node_modules`, `System.*`, `*.dll`, `jdk.internal`, …) collapse, each
+leaving a counted marker behind.
+
+The hook reads the V2 result shape — a string `content` or an array of
+text parts — and rewrites it in place, which keeps the rest of the result
+(metadata, non-text parts) exactly as the tool returned it. Outputs under
+40 characters skip processing entirely. Two deliberate limits remain:
+results truncate at `maxLines` and `maxLineLen` with an overflow marker,
+and the raw output is not kept anywhere, so rerun the command when you
+need it all. Path shortening of the `compact_path` kind is avoided on
+purpose — a path the model cannot open costs more than the characters it
+saves.
+
+```jsonc
+// ~/.config/opencode/opencode.jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": [
+    { "package": "opencode-slim-output",
+      "options": { "maxLines": 120, "maxLineLen": 160, "maxFrames": 40 } },
+  ],
+}
+```
+
+Options beyond the three above are `minFrames` (default 3), `enabled`, and
+`tools` (default `["shell", "bash", "grep", "glob", "read"]`). Restart
+opencode after changing them.
+
+## Develop
+
+```sh
+bun install
+bun test        # 14 tests, incl. adversarial prose fixtures and hook wiring
+bun run typecheck
+```
+
+## License
+
+MIT — © 2026 [Mateo Cerri](https://github.com/mateocerri)

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "opencode-slim-output",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "OpenCode plugin: fail-closed post-processor that collapses external stack frames, relativizes paths and dedups repetitive output.",
+  "type": "module",
+  "main": "plugin.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mateocerri/opencode-slim-output.git"
+  },
+  "homepage": "https://www.npmjs.com/package/opencode-slim-output",
+  "author": "Mateo Cerri",
+  "keywords": ["opencode", "opencode-plugin", "output", "stack-trace", "wsl"],
+  "files": ["plugin.ts", "src", "README.md", "LICENSE"],
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@opencode/plugin": "latest",
+    "bun-types": "^1.4.2",
+    "typescript": "^5.6.0"
+  },
+  "license": "MIT"
+}

package/plugin.ts

@@ -0,0 +1,74 @@
+import { Plugin } from "@opencode/plugin";
+import { slimOutput } from "./src/slim";
+
+interface SlimPluginOptions {
+  maxLines?: number;
+  maxLineLen?: number;
+  maxFrames?: number;
+  minFrames?: number;
+  enabled?: boolean;
+  tools?: string[];
+}
+
+const DEFAULT_TOOLS = ["shell", "bash", "grep", "glob", "read"];
+
+// OpenCode V2 port of the V1 SlimOutputPlugin. Same contract: fail-closed
+// post-processor on tool results. Everything defensive: any doubt about the
+// event shape means passthrough, output untouched.
+export default Plugin.define({
+  id: "slim-output",
+  async setup(ctx) {
+    const o = (ctx.options ?? {}) as SlimPluginOptions;
+    if (o.enabled === false) return;
+    const covered = new Set(o.tools ?? DEFAULT_TOOLS);
+
+    await ctx.tool.hook("execute.after", async (event) => {
+      try {
+        const e = event as unknown as Record<string, unknown>;
+        const input = (e.input ?? e.args ?? {}) as Record<string, unknown>;
+        const tool =
+          (typeof e.tool === "string" && e.tool) ||
+          (typeof input.tool === "string" && input.tool) ||
+          "";
+        if (!tool || !covered.has(tool)) return;
+
+        // V2 result shape: { output?, content?: string | parts[], ... }.
+        // Anything else means passthrough (fail-closed).
+        const result = e.result as { content?: unknown } | undefined;
+        if (!result || typeof result !== "object") return;
+        const command = (typeof input.command === "string" && input.command) || tool;
+        const cwd =
+          (typeof e.directory === "string" && e.directory) ||
+          (typeof input.cwd === "string" && input.cwd) ||
+          undefined;
+        const opts = {
+          cwd,
+          command,
+          maxLines: o.maxLines,
+          maxLineLen: o.maxLineLen,
+          maxFrames: o.maxFrames,
+          minFrames: o.minFrames,
+        };
+        if (typeof result.content === "string") {
+          if (result.content.length < 40) return; // tiny outputs: skip for speed
+          result.content = slimOutput(result.content, opts);
+        } else if (Array.isArray(result.content)) {
+          for (const part of result.content) {
+            if (
+              part &&
+              typeof part === "object" &&
+              (part as { type?: unknown }).type === "text" &&
+              typeof (part as { text?: unknown }).text === "string"
+            ) {
+              const p = part as { text: string };
+              if (p.text.length >= 40) p.text = slimOutput(p.text, opts);
+            }
+          }
+        }
+        return;
+      } catch {
+        // fail-closed: leave output untouched
+      }
+    });
+  },
+});

package/src/slim.ts

@@ -0,0 +1,279 @@
+// slim-output core: fail-closed post-processor for tool output.
+// Pure functions, no opencode deps. Rules:
+// - Non-frame lines are NEVER deleted (errors/summaries always survive).
+// - Frame collapsing requires: command gate + anchor + run of >= minFrames.
+// - Ambiguous input -> passthrough. Never invent paths.
+
+export interface SlimOptions {
+  cwd?: string;
+  command?: string;
+  maxLines?: number;
+  maxLineLen?: number;
+  maxFrames?: number;
+  minFrames?: number;
+}
+
+export type StackKind = "py" | "js" | "dotnet" | "java" | "rust" | "go";
+
+const DEFAULTS = { maxLines: 120, maxLineLen: 160, maxFrames: 40, minFrames: 3 };
+
+// ---- command gates: which detectors may run for a given command/tool ----
+const GATES: Record<StackKind, RegExp> = {
+  py: /(pytest|python|ruff|mypy|basedpyright|ty|uv|poetry|pip)/i,
+  js: /(jest|vitest|tsc|eslint|biome|oxlint|node|bun|deno|npm|yarn|pnpm|nx|turbo|next|playwright|prettier)/i,
+  dotnet: /(dotnet)/i,
+  java: /(mvn|gradle|gradlew|java|spring)/i,
+  rust: /(cargo|rustc|nextest)/i,
+  go: /(^|\s)(go|golangci-lint)(\s|$)/i,
+};
+
+// ---- anchors: wrapper lines proving a stack is present (per kind) ----
+const ANCHORS: Record<StackKind, RegExp> = {
+  py: /Traceback \(most recent call last\)|^\S*(Error|Exception|AssertionError)\b/m,
+  js: /\b(FAIL|Error:|Expected:|Received:|Test Suites:|●)/m,
+  dotnet: /\b(Exception|Failed|error|Error)\b|^\s*at\s+\w+(\.\w+)+\(/m,
+  java: /\b(Exception|Caused by:|FAILED|BUILD FAILURE)\b|^\s*at\s+[\w.$]+\(/m,
+  rust: /\b(panicked|failures:|test result:)/m,
+  go: /\b(FAIL|ok\s+\S+|--- FAIL|panic:|goroutine \d+)\b/m,
+};
+
+// ---- frame shapes: a line must match FULLY to count as a frame ----
+const FRAMES: Record<StackKind, RegExp[]> = {
+  py: [/^\s*File "([^"]+)", line \d+.*$/],
+  js: [/^\s*at\s+.+\([^()]*:\d+:\d+\)\s*$/, /^\s*at\s+\S+\s*$/],
+  dotnet: [/^\s*at\s+[\w.<>$`']+\.[\w.<>$`'()]+\(.*\)(\s+in\s+.*:\d+)?\s*$/],
+  java: [/^\s*at\s+[\w.$]+\.[\w$<>]+\(.*\)(\s+\(.*\))?\s*$/],
+  rust: [/^\s*\d+:\s+\S+.*$/, /^\s*at\s+.*:\d+:\d+\s*$/],
+  go: [/^\s*[\w./\\-]+\.go:\d+.*$/, /^\s*goroutine \d+.*$/],
+};
+
+// ---- external classifiers: frames matching these are collapsible ----
+// Name-based entries are anchored so they can't match project identifiers
+// (e.g. `Object.<anonymous>` must NOT match, `com.sunshine` must NOT match).
+const EXTERNAL: Record<StackKind, RegExp> = {
+  py: /site-packages|dist-packages|\/venv\/|conda|lib\/python\d|<frozen|importlib[./]|runpy[./]|pkg_resources/,
+  js: /node_modules|node:internal|internal\/process|\(<anonymous>\)|\(anonymous\)|node:sea/,
+  dotnet: /\bSystem\.|\bMicrosoft\.|mscorlib|\.dll\b|dotnet[\\/]shared|C:\\Windows|NuGet/,
+  java: /java\.base|jdk\.internal|\bsun\.|org\.junit|org\.gradle|org\.apache\b|com\.sun\.|kotlin\.|scala\./,
+  rust: /core::|std::|alloc::|rustc\/|cargo\/registry/,
+  go: /\/go\/src\/|GOROOT|golang\.org\/toolchain|pkg\/mod\/|GOMODCACHE/,
+};
+
+// Path segments that are external regardless of stack kind.
+const EXTERNAL_HINT = /(node_modules|\.venv|\/venv\/|site-packages|dist-packages|pkg\/mod\/|\/go\/src\/)/;
+
+const EXTERNAL_LABEL: Record<StackKind, string> = {
+  py: "site-packages/stdlib",
+  js: "node_modules/node:internal",
+  dotnet: "System/Microsoft/.dll",
+  java: "jdk/internal",
+  rust: "std/core/registry",
+  go: "stdlib/mod cache",
+};
+
+const ANSI_RE = /\x1b\[[0-9;?]*[a-zA-Z]/g;
+
+export function stripAnsi(s: string): string {
+  return s.replace(ANSI_RE, "");
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** Relativize only the exact cwd prefix — never strip bare src/lib segments. */
+export function relativizePaths(text: string, cwd?: string): string {
+  if (!cwd || cwd === "/" || cwd.length < 2) return text;
+  const norm = cwd.replace(/\/+$/, "");
+  return text.split(norm).join(".");
+}
+
+type LineClass =
+  | { frame: false }
+  | { frame: true; kind: StackKind; external: boolean };
+
+function activeKinds(command: string | undefined, text: string): StackKind[] {
+  const kinds = (Object.keys(GATES) as StackKind[]).filter((k) => {
+    if (!command) return true; // unknown source: allow, anchor still required
+    if (k === "go") return GATES.go.test(` ${command} `);
+    return GATES[k].test(command);
+  });
+  return kinds.filter((k) => ANCHORS[k].test(text));
+}
+
+
+function classifyLine(line: string, kinds: StackKind[]): LineClass {
+  for (const kind of kinds) {
+    if (FRAMES[kind].some((re) => re.test(line))) {
+      // Path hints win over everything: relativized venv/node_modules paths
+      // start with ./ but are still external.
+      if (EXTERNAL_HINT.test(line)) return { frame: true, kind, external: true };
+      if (EXTERNAL[kind].test(line)) return { frame: true, kind, external: true };
+      // Unknown frames are kept (fail-closed): only known-external collapses.
+      return { frame: true, kind, external: false };
+    }
+  }
+  return { frame: false };
+}
+
+/**
+ * Code-context line shown under a frame (e.g. Python prints the source line
+ * after each `File "..."` line). Absorbed into the surrounding frame run so
+ * interleaved tracebacks still form a collapsible run. Emitted verbatim.
+ */
+function isContextLine(line: string): boolean {
+  if (!/^\s+\S/.test(line)) return false;
+  if (line.length > 200) return false;
+  return !/(Error|Exception|assert|Traceback|^\s*(at\b|File\s|Caused by:))/m.test(line);
+}
+
+/** Collapse external sub-runs inside frame runs. Non-frame lines untouched. */
+export function collapseStacks(
+  lines: string[],
+  opts: SlimOptions = {},
+): { lines: string[]; collapsed: number } {
+  const minFrames = opts.minFrames ?? DEFAULTS.minFrames;
+  const maxFrames = opts.maxFrames ?? DEFAULTS.maxFrames;
+  const kinds = activeKinds(opts.command, lines.join("\n"));
+  if (kinds.length === 0) return { lines, collapsed: 0 };
+
+  const cls: LineClass[] = lines.map((l) => classifyLine(l, kinds));
+  const out: string[] = [];
+  let collapsed = 0;
+  let keptFrames = 0;
+  let i = 0;
+
+  while (i < lines.length) {
+    if (!cls[i].frame) {
+      out.push(lines[i]);
+      i++;
+      continue;
+    }
+    // frame run boundaries: absorb single context lines (source snippets
+    // printed under frames) so interleaved tracebacks stay one run
+    let j = i;
+    while (j < lines.length) {
+      if ((cls[j] as LineClass).frame) {
+        j++;
+      } else if (
+        j + 1 < lines.length &&
+        (cls[j + 1] as LineClass).frame &&
+        isContextLine(lines[j])
+      ) {
+        j++; // absorb context line into run
+      } else break;
+    }
+    const run = lines.slice(i, j);
+    const runCls = cls.slice(i, j) as Extract<LineClass, { frame: true }>[];
+
+    if (run.length < minFrames) {
+      // too short to trust -> keep verbatim
+      out.push(...run);
+      keptFrames += run.length;
+      i = j;
+      continue;
+    }
+
+    // Group run into units: each frame plus its attached context line(s).
+    // Context attached to an external frame is dropped with the block;
+    // context attached to a project frame is kept verbatim.
+    type Unit = { external: boolean; kind: StackKind; text: string[] };
+    const units: Unit[] = [];
+    let k = 0;
+    while (k < run.length) {
+      const c = runCls[k] as LineClass;
+      if (c.frame) {
+        const text = [run[k]];
+        let n = k + 1;
+        while (
+          n < run.length &&
+          !(runCls[n] as LineClass).frame &&
+          isContextLine(run[n])
+        ) {
+          text.push(run[n]);
+          n++;
+        }
+        units.push({ external: c.external, kind: c.kind, text });
+        k = n;
+      } else {
+        units.push({ external: false, kind: kinds[0], text: [run[k]] });
+        k++;
+      }
+    }
+
+    // walk units, collapse external blocks (any length >= 1)
+    for (const u of units) {
+      if (!u.external) {
+        for (const t of u.text) {
+          if (keptFrames < maxFrames) {
+            out.push(t);
+            keptFrames++;
+          } else {
+            collapsed++;
+          }
+        }
+        continue;
+      }
+      const label = EXTERNAL_LABEL[u.kind] ?? "external";
+      out.push(`... +1 external frames omitted (${label})`);
+      collapsed += 1;
+    }
+    // merge adjacent markers into a single counted marker
+    for (let m = out.length - 1; m > 0; m--) {
+      const a = out[m].match(/^\.\.\. \+(\d+) external frames omitted \((.+)\)$/);
+      const b = out[m - 1].match(/^\.\.\. \+(\d+) external frames omitted \((.+)\)$/);
+      if (a && b && a[2] === b[2]) {
+        out[m - 1] = `... +${Number(a[1]) + Number(b[1])} frames omitted (${a[2]})`;
+        out.splice(m, 1);
+      }
+    }
+    i = j;
+  }
+
+  return { lines: out, collapsed };
+}
+
+/** Collapse consecutive duplicate lines: a,a,a -> a (x3). */
+export function dedupConsecutive(lines: string[]): string[] {
+  const out: string[] = [];
+  let i = 0;
+  while (i < lines.length) {
+    let j = i + 1;
+    while (j < lines.length && lines[j] === lines[i]) j++;
+    const n = j - i;
+    out.push(n > 1 ? `${lines[i]} (x${n})` : lines[i]);
+    i = j;
+  }
+  return out;
+}
+
+export function truncateLine(line: string, max: number): string {
+  if (line.length <= max) return line;
+  const head = Math.ceil(max * 0.6);
+  const tail = max - head - 1;
+  return line.slice(0, head) + "…" + line.slice(line.length - tail);
+}
+
+export function slimOutput(text: string, opts: SlimOptions = {}): string {
+  if (!text) return text;
+  const maxLines = opts.maxLines ?? DEFAULTS.maxLines;
+  const maxLineLen = opts.maxLineLen ?? DEFAULTS.maxLineLen;
+
+  let clean = relativizePaths(stripAnsi(text).replace(/\r\n/g, "\n"), opts.cwd);
+  let lines = clean.split("\n");
+
+  const { lines: collapsedLines, collapsed } = collapseStacks(lines, opts);
+  lines = dedupConsecutive(collapsedLines);
+  lines = lines.map((l) => truncateLine(l, maxLineLen));
+
+  let truncated = 0;
+  if (lines.length > maxLines) {
+    truncated = lines.length - maxLines;
+    lines = lines.slice(0, maxLines);
+    lines.push(`... +${truncated} more lines (truncated by slim-output)`);
+  }
+  if (collapsed > 0 && truncated === 0) {
+    // marker already inline per collapsed run; nothing extra needed
+  }
+  return lines.join("\n");
+}