agent-sh 0.1.0

package/dist/shell.js

@@ -0,0 +1,219 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import * as pty from "node-pty";
+import { InputHandler } from "./input-handler.js";
+import { OutputParser } from "./output-parser.js";
+export class Shell {
+    ptyProcess;
+    bus;
+    inputHandler;
+    outputParser;
+    paused = false;
+    agentActive = false;
+    tmpDir;
+    constructor(opts) {
+        // Build environment — filter out undefined values (node-pty's native
+        // posix_spawnp fails if any env value is undefined)
+        const env = {};
+        for (const [k, v] of Object.entries(process.env)) {
+            if (v !== undefined)
+                env[k] = v;
+        }
+        env.AGENT_SH = "1";
+        // Spawn the user's shell with their full config (aliases, plugins, PATH,
+        // completions, etc.). The core injects three invisible OSC hooks:
+        //   - OSC 7: cwd tracking (required by OutputParser)
+        //   - OSC 9999: prompt start marker (command boundary detection)
+        //   - OSC 9998: prompt end marker (bracketed prompt capture)
+        // Prompt theming is left entirely to the user's shell config.
+        const shellName = path.basename(opts.shell);
+        const isZsh = shellName.includes("zsh");
+        const isBash = shellName.includes("bash");
+        if (!isZsh && !isBash) {
+            console.warn(`Warning: agent-sh only supports zsh and bash. ` +
+                `"${opts.shell}" may not work correctly — falling back to /bin/bash.`);
+        }
+        const shellBin = (isZsh || isBash) ? opts.shell : "/bin/bash";
+        let shellArgs;
+        const osc7Cmd = 'printf "\\e]7;file://%s%s\\a" "$(hostname)" "$PWD"';
+        const promptMarker = 'printf "\\e]9999;PROMPT\\a"';
+        if (isZsh) {
+            // For zsh: use ZDOTDIR to source user's real config, then append
+            // our hooks via precmd_functions (additive — doesn't clobber p10k/omz).
+            this.tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-sh-"));
+            const userZdotdir = env.ZDOTDIR || env.HOME || os.homedir();
+            fs.writeFileSync(path.join(this.tmpDir, ".zshrc"), [
+                `ZDOTDIR="${userZdotdir}"`,
+                `[ -f "${userZdotdir}/.zshrc" ] && source "${userZdotdir}/.zshrc"`,
+                "",
+                "# agent-sh hooks (invisible OSC sequences for cwd + prompt detection)",
+                "__agent_sh_precmd() {",
+                `  ${osc7Cmd}`,
+                `  ${promptMarker}`,
+                "}",
+                "precmd_functions+=(__agent_sh_precmd)",
+                "",
+                "# End-of-prompt marker via zle-line-init (fires after prompt is rendered)",
+                "# Chain onto existing widget (p10k uses zle-line-init) rather than clobbering",
+                'if (( ${+widgets[zle-line-init]} )); then',
+                "  zle -A zle-line-init __agent_sh_orig_line_init",
+                "  __agent_sh_line_init() {",
+                "    zle __agent_sh_orig_line_init",
+                '    printf "\\e]9998;READY\\a"',
+                "  }",
+                "else",
+                "  __agent_sh_line_init() {",
+                '    printf "\\e]9998;READY\\a"',
+                "  }",
+                "fi",
+                "zle -N zle-line-init __agent_sh_line_init",
+            ].join("\n") + "\n");
+            env.ZDOTDIR = this.tmpDir;
+            shellArgs = ["--no-globalrcs"];
+        }
+        else {
+            // For bash: use --rcfile to source our wrapper, which sources the user's
+            // real bashrc then appends our hooks. No HOME override needed.
+            this.tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-sh-"));
+            const userHome = env.HOME || os.homedir();
+            fs.writeFileSync(path.join(this.tmpDir, ".bashrc"), [
+                `[ -f "${userHome}/.bashrc" ] && source "${userHome}/.bashrc"`,
+                "",
+                "# agent-sh hooks (invisible OSC sequences for cwd + prompt detection)",
+                `PROMPT_COMMAND="\${PROMPT_COMMAND:+\$PROMPT_COMMAND;}${osc7Cmd}; ${promptMarker}"`,
+                "",
+                "# End-of-prompt marker: append to PS1 (\\[...\\] marks it zero-width)",
+                'case "$PS1" in *9998*) ;; *) PS1="${PS1}\\[\\e]9998;READY\\a\\]";; esac',
+            ].join("\n") + "\n");
+            shellArgs = ["--rcfile", path.join(this.tmpDir, ".bashrc")];
+        }
+        this.ptyProcess = pty.spawn(shellBin, shellArgs, {
+            name: "xterm-256color",
+            cols: opts.cols,
+            rows: opts.rows,
+            cwd: opts.cwd,
+            env,
+        });
+        this.bus = opts.bus;
+        this.outputParser = new OutputParser(opts.bus, opts.cwd);
+        // Ensure temp dir cleanup on abnormal exit (SIGKILL won't fire this,
+        // but it covers uncaught exceptions and normal process.exit paths)
+        if (this.tmpDir) {
+            const dir = this.tmpDir;
+            process.on("exit", () => {
+                try {
+                    fs.rmSync(dir, { recursive: true, force: true });
+                }
+                catch { }
+            });
+        }
+        this.inputHandler = new InputHandler({
+            ctx: this,
+            bus: opts.bus,
+            onShowAgentInfo: opts.onShowAgentInfo ?? (() => ({ info: "" })),
+        });
+        this.setupOutput();
+        this.setupInput();
+        this.setupAgentLifecycle();
+    }
+    // ── InputContext implementation (delegates to OutputParser) ──
+    isForegroundBusy() {
+        return this.outputParser.isForegroundBusy();
+    }
+    getCwd() {
+        return this.outputParser.getCwd();
+    }
+    isAgentActive() {
+        return this.agentActive;
+    }
+    writeToPty(data) {
+        this.ptyProcess.write(data);
+    }
+    /**
+     * Lightweight redraw: replay just the last line of the shell's prompt
+     * (e.g. p10k's "❯ "). This works because agent input mode only overwrites
+     * the final prompt line — the path bar above is still intact. The last
+     * line is linear text (colors + chars + clear-to-end), no cursor positioning.
+     */
+    redrawPrompt() {
+        const result = this.bus.emitPipe("shell:redraw-prompt", {
+            cwd: this.outputParser.getCwd(),
+            handled: false,
+        });
+        if (!result.handled) {
+            const lastLine = this.outputParser.getLastPromptLine();
+            if (lastLine) {
+                process.stdout.write("\r" + lastLine);
+            }
+            else {
+                // Fallback: send \n for a fresh prompt cycle
+                this.ptyProcess.write("\n");
+            }
+        }
+    }
+    /**
+     * Heavy redraw: send \n to PTY to trigger a full precmd → prompt cycle.
+     * Use this after agent responses where stdout has moved far from where
+     * zle expects the cursor. The blank line is acceptable as a separator.
+     */
+    freshPrompt() {
+        this.ptyProcess.write("\n");
+    }
+    onCommandEntered(command, cwd) {
+        this.outputParser.onCommandEntered(command, cwd);
+    }
+    // ── PTY I/O wiring ─────────────────────────────────────────
+    setupOutput() {
+        this.ptyProcess.onData((data) => {
+            this.outputParser.processData(data);
+            if (!this.paused) {
+                process.stdout.write(data);
+            }
+        });
+    }
+    setupInput() {
+        process.stdin.on("data", (data) => {
+            const str = data.toString("utf-8");
+            this.inputHandler.handleInput(str);
+        });
+    }
+    /**
+     * React to agent lifecycle events — Shell manages its own state
+     * rather than being driven by AcpClient. This means AcpClient has
+     * zero frontend knowledge; any frontend can subscribe to the same events.
+     */
+    setupAgentLifecycle() {
+        this.bus.on("agent:processing-start", () => {
+            this.agentActive = true;
+            this.paused = true;
+        });
+        this.bus.on("agent:processing-done", () => {
+            this.paused = false;
+            this.agentActive = false;
+            this.freshPrompt();
+        });
+        // Permission prompts need stdout unpaused so the interactive UI renders,
+        // then re-paused after the decision.
+        this.bus.on("permission:request", () => {
+            this.paused = false;
+        });
+        this.bus.onPipeAsync("permission:request", async (payload) => {
+            this.paused = true;
+            return payload;
+        });
+    }
+    // ── Public API (used by index.ts) ──
+    resize(cols, rows) {
+        this.ptyProcess.resize(cols, rows);
+    }
+    onExit(callback) {
+        this.ptyProcess.onExit(callback);
+    }
+    kill() {
+        this.ptyProcess.kill();
+        if (this.tmpDir) {
+            fs.rmSync(this.tmpDir, { recursive: true, force: true });
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,71 @@
+import type { EventBus } from "./event-bus.js";
+import type { ContextManager } from "./context-manager.js";
+import type { AcpClient } from "./acp-client.js";
+import type { ColorPalette } from "./utils/palette.js";
+export interface AgentShellConfig {
+    agentCommand: string;
+    agentArgs: string[];
+    shell?: string;
+    model?: string;
+    extensions?: string[];
+}
+/**
+ * Context passed to user/third-party extensions.
+ * Extensions interact with the system through the event bus — no direct
+ * frontend (Shell/TUI) dependencies. This enables headless, web, or
+ * alternative frontends without changing extensions.
+ */
+export interface ExtensionContext {
+    bus: EventBus;
+    contextManager: ContextManager;
+    getAcpClient: () => AcpClient;
+    quit: () => void;
+    /** Override color palette slots for theming. */
+    setPalette: (overrides: Partial<ColorPalette>) => void;
+}
+export interface TerminalSession {
+    id: string;
+    command: string;
+    output: string;
+    exitCode: number | null;
+    done: boolean;
+    resolve?: (value: void) => void;
+}
+export interface ToolCallRecord {
+    tool: string;
+    args: Record<string, unknown>;
+    output: string;
+    exitCode: number | null;
+}
+export type Exchange = {
+    type: "shell_command";
+    id: number;
+    timestamp: number;
+    cwd: string;
+    command: string;
+    output: string;
+    exitCode: number | null;
+    outputLines: number;
+    outputBytes: number;
+} | {
+    type: "agent_query";
+    id: number;
+    timestamp: number;
+    query: string;
+} | {
+    type: "agent_response";
+    id: number;
+    timestamp: number;
+    response: string;
+    toolCalls: ToolCallRecord[];
+} | {
+    type: "tool_execution";
+    id: number;
+    timestamp: number;
+    tool: string;
+    args: Record<string, unknown>;
+    output: string;
+    exitCode: number | null;
+    outputLines: number;
+    outputBytes: number;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ansi.d.ts

@@ -0,0 +1,12 @@
+export declare const CYAN = "\u001B[36m";
+export declare const DIM = "\u001B[2m";
+export declare const YELLOW = "\u001B[33m";
+export declare const GREEN = "\u001B[32m";
+export declare const RED = "\u001B[31m";
+export declare const GRAY = "\u001B[90m";
+export declare const BOLD = "\u001B[1m";
+export declare const RESET = "\u001B[0m";
+/** Measure visible string length, excluding SGR (color/style) sequences. */
+export declare function visibleLen(str: string): number;
+/** Strip all ANSI escape sequences (SGR, OSC, CSI, private mode) and carriage returns. */
+export declare function stripAnsi(str: string): string;

package/dist/utils/ansi.js

@@ -0,0 +1,23 @@
+// ── ANSI escape code constants ────────────────────────────────
+export const CYAN = "\x1b[36m";
+export const DIM = "\x1b[2m";
+export const YELLOW = "\x1b[33m";
+export const GREEN = "\x1b[32m";
+export const RED = "\x1b[31m";
+export const GRAY = "\x1b[90m";
+export const BOLD = "\x1b[1m";
+export const RESET = "\x1b[0m";
+// ── ANSI utility functions ───────────────────────────────────
+/** Measure visible string length, excluding SGR (color/style) sequences. */
+export function visibleLen(str) {
+    return str.replace(/\x1b\[[^m]*m/g, "").length;
+}
+/** Strip all ANSI escape sequences (SGR, OSC, CSI, private mode) and carriage returns. */
+export function stripAnsi(str) {
+    return str
+        .replace(/\x1b\][^\x07]*\x07/g, "") // OSC sequences
+        .replace(/\x1b\[[^m]*m/g, "") // SGR (color) sequences
+        .replace(/\x1b\[\?[^a-zA-Z]*[a-zA-Z]/g, "") // private mode sequences
+        .replace(/\x1b\[[^a-zA-Z]*[a-zA-Z]/g, "") // CSI sequences
+        .replace(/\r/g, ""); // carriage returns
+}

package/dist/utils/box-frame.d.ts

@@ -0,0 +1,21 @@
+export type BorderStyle = "rounded" | "square" | "double" | "heavy";
+export interface BoxFrameOptions {
+    /** Total width including borders. */
+    width: number;
+    /** Border style. Default "rounded". */
+    style?: BorderStyle;
+    /** Border color (ANSI escape). Default DIM. */
+    borderColor?: string;
+    /** Title text shown in the top border. */
+    title?: string;
+    /** Footer lines shown below a divider, inside the box. */
+    footer?: string[];
+}
+/**
+ * Render content lines inside a bordered frame.
+ *
+ * @param content - Array of pre-rendered content lines (no border)
+ * @param opts - Frame options
+ * @returns Array of terminal-ready lines with borders
+ */
+export declare function renderBoxFrame(content: string[], opts: BoxFrameOptions): string[];

package/dist/utils/box-frame.js

@@ -0,0 +1,60 @@
+/**
+ * Box frame component for bordered TUI panels.
+ *
+ * Follows the render(width) -> string[] protocol — pure function,
+ * never writes to stdout. Supports multiple border styles and
+ * optional title/footer sections with dividers.
+ */
+import { visibleLen } from "./ansi.js";
+import { palette as p } from "./palette.js";
+const BORDERS = {
+    rounded: { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│", ml: "├", mr: "┤" },
+    square: { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" },
+    double: { tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║", ml: "╠", mr: "╣" },
+    heavy: { tl: "┏", tr: "┓", bl: "┗", br: "┛", h: "━", v: "┃", ml: "┣", mr: "┫" },
+};
+// ── Public API ───────────────────────────────────────────────────
+/**
+ * Render content lines inside a bordered frame.
+ *
+ * @param content - Array of pre-rendered content lines (no border)
+ * @param opts - Frame options
+ * @returns Array of terminal-ready lines with borders
+ */
+export function renderBoxFrame(content, opts) {
+    const { width, borderColor = p.dim } = opts;
+    const style = opts.style ?? "rounded";
+    const b = BORDERS[style];
+    const bc = borderColor;
+    // Content area width = total - 2 borders - 2 padding spaces
+    const innerW = Math.max(1, width - 4);
+    const output = [];
+    // Top border (with optional title)
+    if (opts.title) {
+        const titleVis = visibleLen(opts.title);
+        const afterDashes = Math.max(1, width - titleVis - 4);
+        output.push(`${bc}${b.tl}${p.reset} ${opts.title} ${bc}${b.h.repeat(afterDashes)}${b.tr}${p.reset}`);
+    }
+    else {
+        output.push(`${bc}${b.tl}${b.h.repeat(width - 2)}${b.tr}${p.reset}`);
+    }
+    // Content lines
+    for (const line of content) {
+        output.push(boxLine(line, innerW, b.v, bc));
+    }
+    // Footer with divider
+    if (opts.footer && opts.footer.length > 0) {
+        output.push(`${bc}${b.ml}${b.h.repeat(width - 2)}${b.mr}${p.reset}`);
+        for (const line of opts.footer) {
+            output.push(boxLine(line, innerW, b.v, bc));
+        }
+    }
+    // Bottom border
+    output.push(`${bc}${b.bl}${b.h.repeat(width - 2)}${b.br}${p.reset}`);
+    return output;
+}
+// ── Helpers ──────────────────────────────────────────────────────
+function boxLine(text, innerW, v, bc) {
+    const pad = Math.max(0, innerW - visibleLen(text));
+    return `${bc}${v}${p.reset} ${text}${" ".repeat(pad)} ${bc}${v}${p.reset}`;
+}

package/dist/utils/diff-renderer.d.ts

@@ -0,0 +1,20 @@
+import type { DiffResult } from "./diff.js";
+export type DiffDisplayMode = "split" | "unified" | "summary";
+export interface DiffRenderOptions {
+    /** Available terminal width (columns). */
+    width: number;
+    /** Force a specific display mode instead of auto-detecting from width. */
+    mode?: DiffDisplayMode;
+    /** Maximum number of output lines before truncation. Default 50. */
+    maxLines?: number;
+    /** File path to show in the header (also used to detect language for syntax highlighting). */
+    filePath?: string;
+    /** Use true-color (24-bit) backgrounds. Default true. */
+    trueColor?: boolean;
+    /** Enable syntax highlighting on diff lines. Default true. */
+    syntaxHighlight?: boolean;
+}
+/** Select display mode based on available terminal width. */
+export declare function selectMode(width: number): DiffDisplayMode;
+/** Render a diff result as an array of ANSI-formatted terminal lines. */
+export declare function renderDiff(diff: DiffResult, opts: DiffRenderOptions): string[];