@yagni-app/code-staging 1.1.6-staging.1454.1 → 1.1.7-staging.1457.1

package/dist/extension/bashSemantics.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bash exit-code semantics — a port of Claude Code's
+ * `src/tools/BashTool/commandSemantics.ts`.
+ *
+ * Many commands use exit codes to convey information other than success or
+ * failure: grep returns 1 when no matches are found, test returns 1 when the
+ * condition is false — neither is an error. pi's bash tool throws on ANY
+ * non-zero exit (`Command exited with code N`), which marks the result as an
+ * error for both the model and the renderer. This module classifies those
+ * throws so the condensed bash wrapper can demote the benign ones back to
+ * normal results (Claude Code's behavior) while real failures stay errors.
+ *
+ * The classification is a presentation/UX heuristic, NOT a security gate
+ * (Claude Code's own splitter carries the same caveat). It fails CLOSED:
+ * anything it cannot parse confidently — heredocs, negations, env-var
+ * prefixes, `timeout` wrappers — classifies as an error, because a
+ * misclassification must err toward red, never green.
+ */
+/** Exit-code interpretation for one command family. */
+export interface ExitSemantics {
+    /** Whether this exit code is a real error (vs. a benign signal). */
+    isError: boolean;
+    /** Human-readable meaning for a non-error exit code, if any. */
+    message?: string;
+}
+/**
+ * The base command name of the LAST segment (the one that determines the
+ * shell's exit status), mirroring Claude Code's
+ * `heuristicallyExtractBaseCommand`. Fails closed: null for heredocs and
+ * anything unparseable, so the caller applies default semantics.
+ */
+export declare function lastSegmentBaseCommand(command: string): string | null;
+/**
+ * Interpret a command + exit code (Claude Code's `interpretCommandResult`).
+ * Unknown, unparsed, or empty commands use the default semantic (fail closed).
+ */
+export declare function interpretCommandResult(command: string, exitCode: number): ExitSemantics;
+/** The exit-status line pi appends to thrown bash errors (its `appendStatus`). */
+export declare const EXIT_STATUS_LINE_RE: RegExp;
+/** A thrown message parsed as an exit-status error (pi's bash throw format). */
+export interface ExitStatusError {
+    /** The command output above the status line. */
+    output: string;
+    /** The parsed exit code. */
+    exitCode: number;
+}
+/**
+ * Parse a thrown error message as pi's `Command exited with code N` throw
+ * (output + `\n\n` + status line, or the bare status line when output was
+ * empty). Returns undefined for every other throw shape (`Command aborted`,
+ * `Command timed out after N seconds`, arbitrary errors) — callers must
+ * rethrow those untouched.
+ */
+export declare function splitExitStatusError(message: string): ExitStatusError | undefined;
+//# sourceMappingURL=bashSemantics.d.ts.map

package/dist/extension/bashSemantics.js

@@ -0,0 +1,187 @@
+/**
+ * Bash exit-code semantics — a port of Claude Code's
+ * `src/tools/BashTool/commandSemantics.ts`.
+ *
+ * Many commands use exit codes to convey information other than success or
+ * failure: grep returns 1 when no matches are found, test returns 1 when the
+ * condition is false — neither is an error. pi's bash tool throws on ANY
+ * non-zero exit (`Command exited with code N`), which marks the result as an
+ * error for both the model and the renderer. This module classifies those
+ * throws so the condensed bash wrapper can demote the benign ones back to
+ * normal results (Claude Code's behavior) while real failures stay errors.
+ *
+ * The classification is a presentation/UX heuristic, NOT a security gate
+ * (Claude Code's own splitter carries the same caveat). It fails CLOSED:
+ * anything it cannot parse confidently — heredocs, negations, env-var
+ * prefixes, `timeout` wrappers — classifies as an error, because a
+ * misclassification must err toward red, never green.
+ */
+/**
+ * Per-command semantics, mirroring Claude Code's COMMAND_SEMANTICS table.
+ * POSIX exit-code conventions:
+ *   grep/rg: 0 = matches, 1 = no matches, >=2 = error
+ *   find:    0 = success, 1 = partial (inaccessible dirs), >=2 = error
+ *   diff:    0 = same, 1 = differ, >=2 = error
+ *   test/[:  0 = true, 1 = false, >=2 = error
+ */
+const COMMAND_SEMANTICS = new Map([
+    [
+        "grep",
+        (code) => ({
+            isError: code >= 2,
+            message: code === 1 ? "No matches found" : undefined,
+        }),
+    ],
+    [
+        "rg",
+        (code) => ({
+            isError: code >= 2,
+            message: code === 1 ? "No matches found" : undefined,
+        }),
+    ],
+    [
+        "find",
+        (code) => ({
+            isError: code >= 2,
+            message: code === 1 ? "Some directories were inaccessible" : undefined,
+        }),
+    ],
+    [
+        "diff",
+        (code) => ({
+            isError: code >= 2,
+            message: code === 1 ? "Files differ" : undefined,
+        }),
+    ],
+    [
+        "test",
+        (code) => ({
+            isError: code >= 2,
+            message: code === 1 ? "Condition is false" : undefined,
+        }),
+    ],
+    [
+        "[",
+        (code) => ({
+            isError: code >= 2,
+            message: code === 1 ? "Condition is false" : undefined,
+        }),
+    ],
+]);
+/** Default semantic: only 0 is success, everything else is an error. */
+const DEFAULT_SEMANTIC = (code) => ({
+    isError: code !== 0,
+    message: undefined,
+});
+/** Operators that separate command segments (the exit status belongs to the LAST). */
+const SEGMENT_OPERATORS = /(?:&&|\|\||[;|&\n])/;
+/**
+ * Split a command into its top-level segments on `;`, `&&`, `||`, `|`, `&`,
+ * and newlines — quote-aware (`grep 'a;b' x` does not split).
+ * Returns null when the command cannot be split confidently (heredocs,
+ * unbalanced quotes): callers must fail closed on null.
+ */
+function splitSegments(command) {
+    const segments = [];
+    let current = "";
+    let quote = null;
+    for (let i = 0; i < command.length; i++) {
+        const ch = command[i];
+        if (quote) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            current += ch;
+            continue;
+        }
+        if (ch === "\\") {
+            // Escaped next char: copy both, never treat the next char as an operator.
+            current += ch;
+            if (i + 1 < command.length)
+                current += command[++i];
+            continue;
+        }
+        // FD-merge redirects (`2>&1`, `>&1`, `>>&2`, `2>&`): the `&` here is part
+        // of a redirection, NOT a background separator — treating it as one
+        // splits `grep foo bar 2>&1` into a last segment of "1" and the benign
+        // exit 1 stays red (the exact false-error this module exists to demote).
+        // A `&` preceded by `>` (the redirect form) is never a segment boundary.
+        if (ch === "&" && command[i - 1] === ">") {
+            current += ch;
+            continue;
+        }
+        if (SEGMENT_OPERATORS.test(ch)) {
+            segments.push(current);
+            current = "";
+            // Consume the second char of `||` / `&&` so it cannot start a segment.
+            if ((ch === "|" || ch === "&") && command[i + 1] === ch)
+                i++;
+            continue;
+        }
+        current += ch;
+    }
+    if (quote)
+        return null; // Unbalanced quote: fail closed.
+    segments.push(current);
+    return segments;
+}
+/**
+ * The base command name of the LAST segment (the one that determines the
+ * shell's exit status), mirroring Claude Code's
+ * `heuristicallyExtractBaseCommand`. Fails closed: null for heredocs and
+ * anything unparseable, so the caller applies default semantics.
+ */
+export function lastSegmentBaseCommand(command) {
+    if (!command.trim())
+        return null;
+    // Heredoc bodies are arbitrary text; a heuristic misread there must err
+    // toward error, never demote. (Claude Code strips heredocs before parsing;
+    // failing closed is the safe cheaper equivalent.)
+    if (/<<\s*-?\s*['"]?\w/.test(command))
+        return null;
+    const segments = splitSegments(command);
+    if (!segments)
+        return null;
+    const last = segments[segments.length - 1].trim();
+    if (!last)
+        return null;
+    const firstWord = last.split(/\s+/)[0];
+    if (!firstWord)
+        return null;
+    // Env-var assignments (`FOO=1 psql …`) and any prefix we do not recognize
+    // classify via the default semantic (the first word IS the assignment).
+    return firstWord;
+}
+/**
+ * Interpret a command + exit code (Claude Code's `interpretCommandResult`).
+ * Unknown, unparsed, or empty commands use the default semantic (fail closed).
+ */
+export function interpretCommandResult(command, exitCode) {
+    const base = lastSegmentBaseCommand(command);
+    if (!base)
+        return DEFAULT_SEMANTIC(exitCode);
+    const semantic = COMMAND_SEMANTICS.get(base);
+    return semantic ? semantic(exitCode) : DEFAULT_SEMANTIC(exitCode);
+}
+/** The exit-status line pi appends to thrown bash errors (its `appendStatus`). */
+export const EXIT_STATUS_LINE_RE = /\n*(Command exited with code \d+)\s*$/;
+/**
+ * Parse a thrown error message as pi's `Command exited with code N` throw
+ * (output + `\n\n` + status line, or the bare status line when output was
+ * empty). Returns undefined for every other throw shape (`Command aborted`,
+ * `Command timed out after N seconds`, arbitrary errors) — callers must
+ * rethrow those untouched.
+ */
+export function splitExitStatusError(message) {
+    const match = message.match(EXIT_STATUS_LINE_RE);
+    if (!match)
+        return undefined;
+    const exitCode = Number(match[1].match(/\d+/)[0]);
+    const output = message.slice(0, match.index).trimEnd();
+    return { output, exitCode };
+}
+//# sourceMappingURL=bashSemantics.js.map

package/dist/extension/condensedTools.d.ts

@@ -50,7 +50,9 @@ export declare function isScratchpadPath(rawPath: unknown, scratchpadDir: string
 export declare function primaryArg(name: BuiltinName, args: Record<string, unknown> | undefined, cwd?: string): string;
 /** `● Tool(arg)` — the visible-row (and live-row) title line. */
 export declare function formatRowTitle(name: BuiltinName, args: Record<string, unknown> | undefined, status: RowStatus, theme: RenderTheme, cwd?: string): string;
-/** Extract "Command exited with code N" from a bash error body, if present. */
+/** Extract "Command exited with code N" from a bash error body, if present.
+ * The anchor regex lives in bashSemantics (the wrapper's exit-classifier uses
+ * the same format), so parsing stays in one place. */
 export declare function splitBashError(outputText: string): {
     output: string;
     exitLine: string | undefined;

package/dist/extension/condensedTools.js

@@ -29,6 +29,8 @@ import * as path from "node:path";
 import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, getAgentDir, getLanguageFromPath, highlightCode, renderDiff, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { logEvent } from "./errorSink.js";
+import { EXIT_STATUS_LINE_RE, interpretCommandResult, lastSegmentBaseCommand, splitExitStatusError } from "./bashSemantics.js";
+import { isSandboxDenialOutput } from "./sandbox/bash.js";
 import { ReadStateTracker, READ_FIRST_ERROR, readIsPartial, readTextOf, STALE_ERROR } from "./fileGuards.js";
 import { isQuiet, kindForTool, ToolRunTracker } from "./toolRuns.js";
 /** Lines of write content shown collapsed (mirrors Claude Code's preview). */
@@ -146,9 +148,11 @@ export function formatRowTitle(name, args, status, theme, cwd) {
     const title = theme.bold(theme.fg("toolTitle", TITLE_BY_NAME[name]));
     return `${statusDot(status, theme)} ${title}(${theme.fg("accent", primaryArg(name, args, cwd))})`;
 }
-/** Extract "Command exited with code N" from a bash error body, if present. */
+/** Extract "Command exited with code N" from a bash error body, if present.
+ * The anchor regex lives in bashSemantics (the wrapper's exit-classifier uses
+ * the same format), so parsing stays in one place. */
 export function splitBashError(outputText) {
-    const match = outputText.match(/\n*(Command exited with code \d+)\s*$/);
+    const match = outputText.match(EXIT_STATUS_LINE_RE);
     if (!match)
         return { output: outputText.trimEnd(), exitLine: undefined };
     return { output: outputText.slice(0, match.index).trimEnd(), exitLine: match[1] };
@@ -285,6 +289,54 @@ function textComponent(lines) {
 function defaultLoadSettings(cwd) {
     return SettingsManager.create(cwd, getAgentDir());
 }
+/**
+ * Exit-code semantics (Claude Code's commandSemantics port): pi throws on
+ * ANY non-zero exit, but for some commands a non-zero exit is a benign
+ * signal, not an error (grep 1 = no matches, test 1 = false). Classify the
+ * throw: a benign signal becomes a normal result (green row, folds into the
+ * run summary, and the model sees clean output with the interpretation
+ * note); everything else — real failures, aborts, timeouts, sandbox
+ * denials, unknown shapes — returns undefined and the caller rethrows
+ * untouched (fail closed).
+ *
+ * Sandbox denials are detected with the canonical sandbox/bash.ts predicate
+ * (data-vs-diagnostic aware), so a benign grep whose MATCHED OUTPUT happens
+ * to quote a denial line still demotes; a real denial never does.
+ */
+function demoteBashExit(name, args, err) {
+    if (name !== "bash" || !(err instanceof Error))
+        return undefined;
+    const command = typeof args?.command === "string" ? args.command : "";
+    const exit = splitExitStatusError(err.message);
+    if (!exit || isSandboxDenialOutput(err.message))
+        return undefined;
+    const interpretation = interpretCommandResult(command, exit.exitCode);
+    if (interpretation.isError)
+        return undefined;
+    // Sink contract: NEVER raw content on a non-debug line — the base command
+    // is a small closed vocabulary plus args, so log it, not the raw command.
+    logEvent({
+        source: "condensedTools",
+        level: "info",
+        event: "bash_exit_demoted",
+        fields: { baseCommand: lastSegmentBaseCommand(command) ?? "", exitCode: exit.exitCode },
+    });
+    // The model-facing note: pi substitutes "(no output)" for empty output,
+    // which carries no signal — append the interpretation so the model sees
+    // WHY the command exited 1. Non-empty output already speaks for itself.
+    // The match is on TRIMMED equality (not byte-exact) so a drift in pi's
+    // placeholder padding cannot silently drop the note; wording drift fails
+    // the empty-output demote test loudly.
+    const piEmptyPlaceholder = "(no output)";
+    const outputIsPlaceholder = exit.output.trim() === piEmptyPlaceholder;
+    const text = outputIsPlaceholder && interpretation.message
+        ? `${exit.output}\n${interpretation.message}`
+        : exit.output;
+    return {
+        content: [{ type: "text", text }],
+        details: { exitCode: exit.exitCode, returnCodeInterpretation: interpretation.message },
+    };
+}
 /**
  * Re-register the seven built-ins with condensed renderers. Returns the
  * tracker so callers (and tests) can feed message boundaries into it.
@@ -379,7 +431,16 @@ export function registerCondensedTools(pi, deps = {}) {
                         // Not a refusal — delegate and let pi's execute handle it.
                     }
                 }
-                const result = await definitionsFor(cwd)[name].execute(toolCallId, params, signal, onUpdate, ctx);
+                let result;
+                try {
+                    result = await definitionsFor(cwd)[name].execute(toolCallId, params, signal, onUpdate, ctx);
+                }
+                catch (err) {
+                    const demoted = demoteBashExit(name, args, err);
+                    if (!demoted)
+                        throw err;
+                    result = demoted;
+                }
                 // read: record what the model saw. write/edit: the just-written
                 // state is the fresh truth. AWAITED, not fire-and-forget — a follow-up
                 // write/edit in the same burst must not race a pending refresh and
@@ -451,7 +512,12 @@ export function registerCondensedTools(pi, deps = {}) {
                         return textComponent(formatEditBody(args.path, result.details, true, theme, slice.cwd));
                     }
                     const output = textOf(result);
-                    return output ? textComponent(formatExpandedOutput(output, theme)) : empty();
+                    if (output)
+                        return textComponent(formatExpandedOutput(output, theme));
+                    // A demoted benign exit (grep no-match) with empty output: Claude
+                    // Code shows the interpretation as the dim row body — mirror it.
+                    const interpretation = result.details?.returnCodeInterpretation;
+                    return name === "bash" && interpretation ? textComponent([`  ${theme.fg("muted", "⎿")} ${theme.fg("dim", interpretation)}`]) : empty();
                 }
                 // Backgrounded bash: the launch line (id + output path) plus a dim
                 // manage hint — BEFORE the quiet-run collapse, so a backgrounded call

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.1.6-staging.1454.1",
+  "version": "1.1.7-staging.1457.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "d2f1a9de6f763b2144382fb42fed7cf36efa431a"
+  "yagniSourceSha": "84e42e8d01be3c12114488a3f5961df75774a9b2"
 }