@aerode/pish 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dacapoday
+
+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

@@ -0,0 +1,129 @@
+# pish
+
+**Your shell, with AI built in.**
+
+pish wraps bash or zsh transparently. Every command you know works exactly as before — zero overhead. When you type something the shell doesn't recognize, an AI agent ([pi](https://github.com/badlogic/pi-mono)) kicks in automatically.
+
+<p align="center">
+  <img src="pish-example.gif" alt="pish demo" width="600">
+</p>
+
+## How it works
+
+pish runs your shell inside a PTY with lightweight hooks injected via rcfile. Normal commands flow through untouched. Only when `command_not_found` fires does pish intercept — it sends your recent shell history as context to the AI agent, which can read files, run commands, and edit code.
+
+```
+You ←→ pish (Node.js) ←→ PTY (bash/zsh + hooks)
+              ↓
+        Agent (pi --mode rpc, on demand)
+              ↓
+        Renderer → stderr
+```
+
+Agent output goes to **stderr**, never contaminating your shell's stdout. Your prompt, pipes, and redirections work exactly as expected.
+
+## Quick start
+
+**Requirements:**
+- Node.js ≥ 18
+- bash ≥ 4.4 or zsh ≥ 5.0
+- [`pi`](https://github.com/badlogic/pi-mono) installed and on PATH
+
+### Install from npm
+
+```bash
+npm install -g pish
+```
+
+### Install from source
+
+```bash
+git clone https://github.com/dacapoday/pish.git
+cd pish
+npm install
+npm run build
+npm link          # makes `pish` available globally
+```
+
+### Run
+
+```bash
+pish                            # start with $SHELL (or bash)
+pish zsh                        # start with zsh
+pish /usr/local/bin/bash        # use a specific shell binary
+pish --pi /path/to/pi           # use a specific pi binary
+```
+
+## Usage
+
+### Normal commands
+
+Everything works exactly like your regular shell — aliases, functions, pipes, redirections, job control, history, tab completion.
+
+### AI agent
+
+Type anything the shell doesn't recognize. The agent sees your recent commands and their outputs as context:
+
+```
+❯ find all TODO comments in src/
+⠋ Working...
+  $ grep -rn "TODO" src/
+✓ done (2.1s)
+```
+
+### Reverse to pi TUI
+
+Type `pi` with no arguments to open the full pi TUI. Your conversation carries over — the AI remembers everything from the current session. When you exit pi, you're back in pish.
+
+### Control commands
+
+```
+/compact [instructions]     # compact agent context
+/model provider/model       # switch model
+/think [level]              # set thinking level (none/low/medium/high)
+```
+
+### Keyboard shortcuts
+
+| Key | Action |
+|-----|--------|
+| `Ctrl+C` | Abort running agent |
+| `Ctrl+L` | Clear screen + reset context + reset session |
+
+## Configuration
+
+Priority: **CLI > ENV > defaults**
+
+```
+pish [options] [shell]
+
+Options:
+  -s, --shell <name>  Shell name or path
+  --pi <path>         Path to pi binary
+  --no-agent          Disable agent (for debugging)
+  -v, --version       Show version
+  -h, --help          Show help
+```
+
+| Environment variable | Description | Default |
+|---------------------|-------------|---------|
+| `PISH_SHELL` | Shell name or path | `$SHELL` or `bash` |
+| `PISH_PI` | Path to pi binary | `pi` |
+| `PISH_MAX_CONTEXT` | Max history entries sent to AI | `20` |
+| `PISH_HEAD_LINES` | Output head lines kept | `50` |
+| `PISH_TAIL_LINES` | Output tail lines kept | `30` |
+| `PISH_LINE_WIDTH` | Max chars per line | `512` |
+| `PISH_TOOL_LINES` | Max tool result lines shown | `10` |
+| `PISH_LOG` | Event log (`stderr` or file path) | off |
+| `PISH_DEBUG` | Debug log file path | off |
+| `PISH_NO_BANNER` | Hide startup banner (set to `1`) | off |
+
+
+## Known limitations
+
+- **Bash keywords** — `do something` or `if something` triggers a syntax error instead of the AI agent. Rephrase as `please do something`.
+- **CNF returns 0** — `$?` after an agent run is always 0, not 127.
+
+## License
+
+[MIT](LICENSE) © [dacapoday](https://github.com/dacapoday)

package/dist/agent.js

@@ -0,0 +1,398 @@
+/**
+ * Agent subprocess manager.
+ *
+ * Spawns `pi --mode rpc`, communicates via stdin/stdout JSONL.
+ * Lifecycle: lazy spawn, restart on crash, abort on interrupt.
+ *
+ * Raw pi RPC events → flattened AgentEvent (consumed directly by renderer).
+ */
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { StringDecoder } from 'node:string_decoder';
+import { log } from './log.js';
+/** Safely extract a string from an unknown value. */
+function str(v) {
+    return typeof v === 'string' ? v : '';
+}
+/** Safely extract a number from an unknown value. */
+function num(v) {
+    return typeof v === 'number' ? v : 0;
+}
+/** Convert a raw JSON message to a typed RpcResponse. */
+function toRpcResponse(obj) {
+    return {
+        type: 'response',
+        id: typeof obj.id === 'string' ? obj.id : undefined,
+        command: typeof obj.command === 'string' ? obj.command : undefined,
+        success: obj.success === true,
+        data: (typeof obj.data === 'object' && obj.data !== null
+            ? obj.data
+            : undefined),
+        error: typeof obj.error === 'string' ? obj.error : undefined,
+    };
+}
+export class AgentManager {
+    proc = null;
+    buf = '';
+    cb = null;
+    _running = false;
+    _submitted = false;
+    startTime = 0;
+    lastUsage = null;
+    piPath;
+    pendingRpc = new Map();
+    /** Current session file path. Maintained by pish across agent process restarts. */
+    sessionFile;
+    /** Crash info (in-memory), displayed on next enterAgentMode */
+    crashInfo;
+    constructor(piPath = 'pi') {
+        this.piPath = piPath;
+    }
+    get running() {
+        return this._running;
+    }
+    /** Whether the agent process is alive and writable. */
+    get alive() {
+        return this.proc !== null && !this.proc.killed;
+    }
+    onEvent(cb) {
+        this.cb = cb;
+    }
+    /** Ensure the pi process is alive (lazy spawn). */
+    ensureRunning() {
+        if (this.proc && !this.proc.killed)
+            return;
+        const args = ['--mode', 'rpc'];
+        if (this.sessionFile) {
+            args.push('--session', this.sessionFile);
+        }
+        log('agent_spawn', { args });
+        this.proc = spawn(this.piPath, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+        this.buf = '';
+        const decoder = new StringDecoder('utf8');
+        this.proc.stdout.on('data', (data) => {
+            this.buf += decoder.write(data);
+            const lines = this.buf.split('\n');
+            this.buf = lines.pop();
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    this.parseLine(obj);
+                }
+                catch {
+                    log('agent_parse_error', { line });
+                }
+            }
+        });
+        // Ignore pi stderr (its own debug output)
+        this.proc.stderr.on('data', () => { });
+        // Handle stdin errors (EPIPE if process dies before/during write)
+        this.proc.stdin.on('error', (err) => {
+            if (err.code === 'EPIPE' || err.code === 'ERR_STREAM_DESTROYED')
+                return;
+            log('agent_stdin_error', { error: String(err) });
+        });
+        this.proc.on('exit', (code, signal) => {
+            log('agent_exit', { code, signal });
+            const wasActive = this._running || this._submitted;
+            this.proc = null;
+            this._running = false;
+            this._submitted = false;
+            // Reject all pending RPC promises (process died)
+            for (const [, pending] of this.pendingRpc) {
+                clearTimeout(pending.timer);
+                pending.resolve({
+                    type: 'response',
+                    success: false,
+                    error: `pi exited (code=${code})`,
+                });
+            }
+            this.pendingRpc.clear();
+            if (wasActive) {
+                // Crashed while running or after submit but before agent_start
+                this.emitEvent({
+                    type: 'agent_error',
+                    error: `pi exited unexpectedly (code=${code}, signal=${signal})`,
+                });
+            }
+            // Non-zero exit (not SIGTERM) → store crash info for next agent mode
+            if (code !== null &&
+                code !== 0 &&
+                signal !== 'SIGTERM' &&
+                signal !== 'SIGKILL') {
+                this.crashInfo = `agent process exited unexpectedly (code ${code})`;
+            }
+        });
+    }
+    // ── JSONL event parsing + flattening ──
+    parseLine(obj) {
+        const type = obj.type;
+        if (!type)
+            return;
+        switch (type) {
+            case 'message_update':
+                this.handleMessageUpdate(obj);
+                break;
+            case 'tool_execution_start':
+                this.emitEvent({
+                    type: 'tool_start',
+                    toolCallId: str(obj.toolCallId),
+                    toolName: str(obj.toolName),
+                    args: (obj.args ?? {}),
+                });
+                break;
+            case 'tool_execution_update':
+                this.emitEvent({
+                    type: 'tool_update',
+                    toolCallId: str(obj.toolCallId),
+                    toolName: str(obj.toolName),
+                    partialResult: obj.partialResult,
+                });
+                break;
+            case 'tool_execution_end':
+                this.emitEvent({
+                    type: 'tool_end',
+                    toolCallId: str(obj.toolCallId),
+                    toolName: str(obj.toolName),
+                    result: obj.result,
+                    isError: obj.isError ?? false,
+                });
+                break;
+            case 'turn_end':
+                this.emitEvent({ type: 'turn_end' });
+                break;
+            case 'message_end': {
+                const msg = obj.message;
+                if (msg?.role === 'assistant' && msg.usage) {
+                    const u = msg.usage;
+                    const cost = u.cost;
+                    this.lastUsage = {
+                        inputTokens: num(u.input),
+                        outputTokens: num(u.output),
+                        cacheRead: num(u.cacheRead),
+                        cacheWrite: num(u.cacheWrite),
+                        totalTokens: num(u.totalTokens),
+                        cost: num(cost?.total),
+                        model: str(msg.model),
+                        provider: str(msg.provider),
+                        thinkingLevel: '',
+                        contextPercent: null,
+                        contextWindow: 0,
+                    };
+                }
+                break;
+            }
+            case 'agent_start':
+                this._running = true;
+                this._submitted = false;
+                this.startTime = Date.now();
+                this.lastUsage = null;
+                break;
+            case 'agent_end':
+                this._running = false;
+                this.emitEvent({
+                    type: 'agent_done',
+                    durationMs: Date.now() - this.startTime,
+                    usage: this.aggregateUsage(obj),
+                });
+                break;
+            case 'response': {
+                const rpc = toRpcResponse(obj);
+                // Match pending rpcWait() by id
+                if (rpc.id && this.pendingRpc.has(rpc.id)) {
+                    const pending = this.pendingRpc.get(rpc.id);
+                    this.pendingRpc.delete(rpc.id);
+                    clearTimeout(pending.timer);
+                    pending.resolve(rpc);
+                    break;
+                }
+                // Unmatched RPC error → emit agent_error
+                if (!rpc.success && rpc.error) {
+                    this.emitEvent({ type: 'agent_error', error: rpc.error });
+                }
+                break;
+            }
+            case 'auto_compaction_start':
+                this.emitEvent({
+                    type: 'compaction_start',
+                    reason: str(obj.reason) || 'threshold',
+                });
+                break;
+            case 'auto_compaction_end': {
+                const result = obj.result;
+                this.emitEvent({
+                    type: 'compaction_end',
+                    summary: result?.summary,
+                    aborted: obj.aborted ?? false,
+                    error: obj.errorMessage,
+                });
+                break;
+            }
+            // Ignored: extension_ui_request, session header, etc.
+        }
+    }
+    handleMessageUpdate(obj) {
+        const ame = obj.assistantMessageEvent;
+        if (!ame)
+            return;
+        switch (ame.type) {
+            case 'thinking_start':
+                this.emitEvent({ type: 'thinking_start' });
+                break;
+            case 'thinking_delta':
+                this.emitEvent({ type: 'thinking_delta', delta: str(ame.delta) });
+                break;
+            case 'thinking_end':
+                this.emitEvent({ type: 'thinking_end', content: str(ame.content) });
+                break;
+            case 'text_start':
+                this.emitEvent({ type: 'text_start' });
+                break;
+            case 'text_delta':
+                this.emitEvent({ type: 'text_delta', delta: str(ame.delta) });
+                break;
+            case 'text_end':
+                this.emitEvent({ type: 'text_end', content: str(ame.content) });
+                break;
+            // toolcall_start/delta/end handled by tool_execution_* events
+        }
+    }
+    /** Aggregate usage from agent_end messages array. */
+    aggregateUsage(agentEnd) {
+        const messages = agentEnd.messages;
+        if (!Array.isArray(messages)) {
+            return this.lastUsage ?? undefined;
+        }
+        let input = 0;
+        let output = 0;
+        let cacheRead = 0;
+        let cacheWrite = 0;
+        let total = 0;
+        let cost = 0;
+        let model = '';
+        let provider = '';
+        for (const msg of messages) {
+            if (msg.role === 'assistant' && msg.usage) {
+                const u = msg.usage;
+                const c = u.cost;
+                input += num(u.input);
+                output += num(u.output);
+                cacheRead += num(u.cacheRead);
+                cacheWrite += num(u.cacheWrite);
+                total += num(u.totalTokens);
+                cost += num(c?.total);
+                if (msg.model)
+                    model = str(msg.model);
+                if (msg.provider)
+                    provider = str(msg.provider);
+            }
+        }
+        if (total === 0)
+            return this.lastUsage ?? undefined;
+        return {
+            inputTokens: input,
+            outputTokens: output,
+            cacheRead,
+            cacheWrite,
+            totalTokens: total,
+            cost,
+            model,
+            provider,
+            thinkingLevel: '',
+            contextPercent: null,
+            contextWindow: 0,
+        };
+    }
+    emitEvent(event) {
+        this.cb?.(event);
+    }
+    /** Submit a prompt to the agent. */
+    submit(message) {
+        this.ensureRunning();
+        if (!this.proc?.stdin?.writable) {
+            this.emitEvent({
+                type: 'agent_error',
+                error: 'pi process not available',
+            });
+            return;
+        }
+        this._submitted = true;
+        const cmd = `${JSON.stringify({ type: 'prompt', message })}\n`;
+        this.proc.stdin.write(cmd);
+    }
+    /** Abort the current agent run. */
+    abort() {
+        if (!this.proc?.stdin?.writable)
+            return;
+        const cmd = `${JSON.stringify({ type: 'abort' })}\n`;
+        this.proc.stdin.write(cmd);
+    }
+    /** Send an RPC command (fire-and-forget). */
+    rpc(command) {
+        this.ensureRunning();
+        if (!this.proc?.stdin?.writable)
+            return;
+        this.proc.stdin.write(`${JSON.stringify(command)}\n`);
+    }
+    /** Send an RPC command and wait for the matching response. */
+    async rpcWait(command, timeoutMs = 30000) {
+        this.ensureRunning();
+        if (!this.proc?.stdin?.writable) {
+            return {
+                type: 'response',
+                success: false,
+                error: 'pi process not available',
+            };
+        }
+        const id = randomUUID();
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (this.pendingRpc.delete(id)) {
+                    resolve({ type: 'response', success: false, error: 'RPC timeout' });
+                }
+            }, timeoutMs);
+            this.pendingRpc.set(id, { resolve, timer });
+            this.proc.stdin.write(`${JSON.stringify({ ...command, id })}\n`);
+        });
+    }
+    /** Kill the process but preserve sessionFile. */
+    kill() {
+        // Resolve pending RPCs before killing
+        for (const [, pending] of this.pendingRpc) {
+            clearTimeout(pending.timer);
+            pending.resolve({
+                type: 'response',
+                success: false,
+                error: 'agent killed',
+            });
+        }
+        this.pendingRpc.clear();
+        if (this.proc && !this.proc.killed) {
+            const p = this.proc;
+            p.kill('SIGTERM');
+            // Escalate to SIGKILL if process doesn't exit within 2s
+            const forceKill = setTimeout(() => {
+                try {
+                    p.kill('SIGKILL');
+                }
+                catch {
+                    /* already exited */
+                }
+            }, 2000);
+            forceKill.unref(); // Don't prevent Node from exiting
+            this.proc = null;
+        }
+        this._running = false;
+        this._submitted = false;
+    }
+    /** Kill process + clear session (full reset via Ctrl+L). */
+    reset() {
+        this.kill();
+        this.sessionFile = undefined;
+    }
+}