@aerode/pish 0.8.0

package/dist/app.js

@@ -0,0 +1,473 @@
+/**
+ * App — core application object.
+ *
+ * Owns all mutable session state (mode, FIFO, reverse tracking).
+ * Receives events from Recorder and AgentManager, drives rendering
+ * and FIFO responses. Created by main.ts after all resources are ready.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { closeLog, log } from './log.js';
+import { printBanner, printControl, printControlResult, printExit, printNotice, StreamRenderer, startSpinner, } from './render.js';
+// ═══════════════════════════════════════
+// Pure helpers (module-level, no `this`)
+// ═══════════════════════════════════════
+function formatContext(entries) {
+    return entries
+        .map((e, i) => {
+        const parts = [];
+        const num = `[${i + 1}]`;
+        if (e.prompt) {
+            parts.push(`${num} ${e.prompt}`);
+        }
+        else {
+            parts.push(num);
+        }
+        if (e.output)
+            parts.push(e.output);
+        if (e.rc !== 0)
+            parts.push(`[exit code: ${e.rc}]`);
+        return parts.join('\n');
+    })
+        .join('\n\n');
+}
+/** pi agent directory, respects PI_CODING_AGENT_DIR env var. */
+function getAgentDir() {
+    const envDir = process.env.PI_CODING_AGENT_DIR;
+    if (envDir) {
+        if (envDir === '~')
+            return os.homedir();
+        if (envDir.startsWith('~/'))
+            return os.homedir() + envDir.slice(1);
+        return envDir;
+    }
+    return path.join(os.homedir(), '.pi', 'agent');
+}
+/** CWD encoding rule, matching pi's getDefaultSessionDir. */
+function cwdToSessionSubdir(cwd) {
+    return `--${cwd.replace(/^[\/\\]/, '').replace(/[\/\\:]/g, '-')}--`;
+}
+/**
+ * Find the latest session file in the CWD session directory with mtime > since.
+ */
+async function findLatestSession(since, debug) {
+    const cwdSessionDir = path.join(getAgentDir(), 'sessions', cwdToSessionSubdir(process.cwd()));
+    let files;
+    try {
+        files = await fs.promises.readdir(cwdSessionDir);
+    }
+    catch {
+        return null; // directory doesn't exist
+    }
+    let latest = null;
+    for (const file of files) {
+        if (!file.endsWith('.jsonl'))
+            continue;
+        try {
+            const filePath = path.join(cwdSessionDir, file);
+            const fstat = await fs.promises.stat(filePath);
+            const mtime = fstat.mtimeMs;
+            if (mtime > since && (!latest || mtime > latest.mtime)) {
+                latest = { path: filePath, mtime };
+            }
+        }
+        catch {
+            debug('findLatestSession: stat error for', file);
+        }
+    }
+    return latest?.path ?? null;
+}
+// ═══════════════════════════════════════
+// App
+// ═══════════════════════════════════════
+export class App {
+    // ── Injected dependencies ──
+    cfg;
+    pty;
+    recorder;
+    agent;
+    // ── Infrastructure (immutable after construction) ──
+    fifoPath;
+    tmpDir;
+    rcPath;
+    debugFd;
+    // ── FIFO ──
+    fifoFd = null;
+    cleaned = false;
+    // ── Agent mode state ──
+    mode = 'normal';
+    agentCmd = '';
+    agentStartTime = 0;
+    stdinBuffer = [];
+    renderer = null;
+    // ── Reverse session recovery ──
+    sessionEpoch = Date.now();
+    reverseStartTime = 0;
+    preReverseSessionFile;
+    constructor(deps, infra) {
+        this.cfg = deps.cfg;
+        this.pty = deps.pty;
+        this.recorder = deps.recorder;
+        this.agent = deps.agent;
+        this.fifoPath = infra.fifoPath;
+        this.tmpDir = infra.tmpDir;
+        this.rcPath = infra.rcPath;
+        // Open debug log file (same file shell hooks append to)
+        const debugPath = process.env.PISH_DEBUG;
+        this.debugFd = debugPath ? fs.openSync(debugPath, 'a') : null;
+        // Wire internal event handlers
+        this.agent.onEvent((event) => this.onAgentEvent(event));
+        this.recorder.onEvent((evt) => this.onRecorderEvent(evt));
+    }
+    // ═══════════════════════════════════════
+    // Public I/O interface (called by main.ts wiring)
+    // ═══════════════════════════════════════
+    /** PTY stdout data → recorder + terminal. */
+    onPtyData(data) {
+        const clean = this.recorder.feed(data);
+        process.stdout.write(clean);
+    }
+    /** PTY process exited. */
+    onPtyExit(code) {
+        this.debugLog('PTY exited, code:', code);
+        printExit();
+        log('exit', { context_count: this.recorder.context.length, code });
+        closeLog();
+        this.cleanup();
+        process.exit(code);
+    }
+    /** Terminal stdin data → mode routing. */
+    onStdin(data) {
+        if (this.mode === 'agent') {
+            if (data.length === 1 && data[0] === 0x03) {
+                this.abortAgent();
+            }
+            else {
+                this.stdinBuffer.push(Buffer.from(data));
+            }
+            return;
+        }
+        // Ctrl+L: clear screen + reset context + full agent reset (including session)
+        if (data.length === 1 && data[0] === 0x0c) {
+            const cleared = this.recorder.drain();
+            log('context_clear', { discarded: cleared.length });
+            this.agent.reset();
+            this.sessionEpoch = Date.now();
+            this.preReverseSessionFile = undefined;
+            this.pty.write(data.toString());
+            return;
+        }
+        this.pty.write(data.toString());
+    }
+    /** Terminal resized. */
+    onResize(cols, rows) {
+        this.pty.resize(cols, rows);
+    }
+    /** Cleanup all resources. Public — called by signal handlers in main.ts. */
+    cleanup() {
+        if (this.cleaned)
+            return;
+        this.cleaned = true;
+        process.stderr.write('\x1b[?25h'); // Restore cursor visibility
+        this.agent.kill();
+        if (this.fifoFd !== null) {
+            try {
+                fs.closeSync(this.fifoFd);
+            }
+            catch {
+                /* fd may already be closed */
+            }
+            this.fifoFd = null;
+        }
+        try {
+            fs.unlinkSync(this.fifoPath);
+        }
+        catch {
+            /* already removed or never created */
+        }
+        try {
+            fs.rmSync(this.tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            /* non-empty or already removed */
+        }
+        try {
+            fs.unlinkSync(this.rcPath);
+            fs.rmSync(path.dirname(this.rcPath), { recursive: true, force: true });
+        }
+        catch {
+            /* zsh rcdir may not exist or already cleaned */
+        }
+        if (this.debugFd !== null) {
+            try {
+                fs.closeSync(this.debugFd);
+            }
+            catch {
+                /* fd may already be closed */
+            }
+        }
+    }
+    // ═══════════════════════════════════════
+    // Agent event handler
+    // ═══════════════════════════════════════
+    onAgentEvent(event) {
+        this.renderer?.handleEvent(event);
+        if (event.type === 'agent_done' && this.mode === 'agent') {
+            log('agent_done', {
+                cmd: this.agentCmd,
+                duration_ms: Date.now() - this.agentStartTime,
+            });
+            this.exitAgentMode();
+        }
+        if (event.type === 'agent_error' && this.mode === 'agent') {
+            log('agent_error', { cmd: this.agentCmd, error: event.error });
+            this.exitAgentMode();
+        }
+    }
+    // ═══════════════════════════════════════
+    // Recorder event handler
+    // ═══════════════════════════════════════
+    onRecorderEvent(evt) {
+        switch (evt.type) {
+            case 'shell_ready':
+                this.debugLog('EVENT: shell_ready');
+                this.fifoFd = fs.openSync(this.fifoPath, 'w');
+                this.debugLog('FIFO write fd opened');
+                log('shell_ready', { pid: this.pty.pid });
+                printBanner(this.cfg);
+                break;
+            case 'context':
+                log('context', {
+                    prompt: evt.entry.prompt,
+                    output: evt.entry.output,
+                    rc: evt.entry.rc,
+                    kept: this.recorder.context.length,
+                });
+                break;
+            case 'context_skip':
+                log('context_skip', { reason: evt.reason });
+                break;
+            case 'agent':
+                this.handleAgentCmd(evt.cmd);
+                break;
+            case 'reverse':
+                this.handleReverse();
+                break;
+            case 'reverse_done':
+                this.handleReverseDone().catch((err) => {
+                    log('reverse_done_error', { error: String(err) });
+                });
+                break;
+            case 'error':
+                log('error', { msg: evt.msg });
+                process.stderr.write(`\x1b[31mpish: ${evt.msg}\x1b[0m\n`);
+                this.cleanup();
+                process.exit(1);
+                break;
+        }
+    }
+    // ═══════════════════════════════════════
+    // Agent mode transitions
+    // ═══════════════════════════════════════
+    enterAgentMode(cmd) {
+        this.mode = 'agent';
+        this.agentCmd = cmd;
+        this.agentStartTime = Date.now();
+        this.stdinBuffer = [];
+        this.debugLog('enterAgentMode:', cmd);
+        const entries = this.recorder.drain();
+        log('agent', { cmd, context_count: entries.length });
+        this.renderer = new StreamRenderer(this.cfg.toolResultLines);
+        if (this.agent.crashInfo) {
+            printNotice(this.agent.crashInfo);
+            this.agent.crashInfo = undefined;
+        }
+        this.renderer.showSpinner();
+        let message = cmd;
+        const ctx = formatContext(entries);
+        if (ctx) {
+            message = `Here is my recent shell activity:\n\n${ctx}\n\n${cmd}`;
+        }
+        this.agent.submit(message);
+    }
+    exitAgentMode() {
+        this.debugLog('exitAgentMode, stdinBuffer:', this.stdinBuffer.length, 'chunks');
+        this.mode = 'normal';
+        this.renderer = null;
+        this.fifoWrite('PROCEED');
+        // Request state to get session file (for subsequent reverse).
+        // Only if agent process is alive — don't respawn after crash.
+        if (this.agent.alive) {
+            this.agent
+                .rpcWait({ type: 'get_state' }, 5000)
+                .then((response) => {
+                if (response.success && response.data?.sessionFile) {
+                    this.agent.sessionFile = response.data.sessionFile;
+                }
+            })
+                .catch((err) => {
+                log('get_state_error', { error: String(err) });
+            });
+        }
+        const buffered = this.stdinBuffer;
+        this.stdinBuffer = [];
+        if (buffered.length > 0) {
+            setTimeout(() => {
+                for (const chunk of buffered) {
+                    this.pty.write(chunk.toString());
+                }
+                this.debugLog('replayed', buffered.length, 'stdin chunks');
+            }, 50);
+        }
+    }
+    abortAgent() {
+        this.debugLog('abortAgent');
+        this.agent.abort();
+        this.renderer?.printInterrupted();
+        log('agent_abort', {
+            cmd: this.agentCmd,
+            duration_ms: Date.now() - this.agentStartTime,
+        });
+        this.mode = 'normal';
+        this.renderer = null;
+        this.stdinBuffer = [];
+        this.fifoWrite('PROCEED');
+    }
+    // ═══════════════════════════════════════
+    // Agent / control command dispatch
+    // ═══════════════════════════════════════
+    handleAgentCmd(cmd) {
+        this.debugLog('EVENT: agent cmd=', cmd);
+        if (cmd.startsWith('/')) {
+            log('control', { cmd });
+            printControl(cmd);
+            if (this.cfg.noAgent) {
+                this.fifoWrite('PROCEED');
+                return;
+            }
+            this.handleControlAsync(cmd)
+                .then((response) => {
+                if (response)
+                    printControlResult(cmd, response);
+            })
+                .catch((err) => {
+                log('control_error', { cmd, error: String(err) });
+            })
+                .finally(() => {
+                this.fifoWrite('PROCEED');
+            });
+            return;
+        }
+        if (this.cfg.noAgent) {
+            log('agent_skip', { cmd, reason: 'no-agent' });
+            printNotice(`agent disabled, skipped: ${cmd}`);
+            this.fifoWrite('PROCEED');
+            return;
+        }
+        this.enterAgentMode(cmd);
+    }
+    async handleControlAsync(cmd) {
+        const parts = cmd.trim().split(/\s+/);
+        const name = parts[0];
+        const arg = parts.slice(1).join(' ');
+        switch (name) {
+            case '/compact': {
+                const stopSpinner = startSpinner('Compacting...');
+                try {
+                    return await this.agent.rpcWait({ type: 'compact', ...(arg ? { customInstructions: arg } : {}) }, 60000);
+                }
+                finally {
+                    stopSpinner();
+                }
+            }
+            case '/model': {
+                if (!arg) {
+                    const state = await this.agent.rpcWait({ type: 'get_state' }, 5000);
+                    if (state.success && state.data?.model) {
+                        const m = state.data.model;
+                        const prov = m.provider;
+                        const provider = typeof prov === 'object' && prov !== null
+                            ? (prov.id ?? '')
+                            : String(prov ?? '');
+                        const modelId = m.id ?? '';
+                        return {
+                            type: 'response',
+                            command: 'set_model',
+                            success: true,
+                            data: { provider: { id: provider }, id: modelId },
+                        };
+                    }
+                    return {
+                        type: 'response',
+                        command: 'set_model',
+                        success: false,
+                        error: 'no model info available',
+                    };
+                }
+                const slashIdx = arg.indexOf('/');
+                if (slashIdx > 0) {
+                    return await this.agent.rpcWait({
+                        type: 'set_model',
+                        provider: arg.slice(0, slashIdx),
+                        modelId: arg.slice(slashIdx + 1),
+                    }, 10000);
+                }
+                else {
+                    return await this.agent.rpcWait({ type: 'set_model', provider: '', modelId: arg }, 10000);
+                }
+            }
+            case '/think': {
+                const level = arg || 'medium';
+                return await this.agent.rpcWait({ type: 'set_thinking_level', level }, 5000);
+            }
+            default:
+                return null;
+        }
+    }
+    // ═══════════════════════════════════════
+    // Reverse session recovery
+    // ═══════════════════════════════════════
+    handleReverse() {
+        this.debugLog('EVENT: reverse');
+        const sessionFile = this.agent.sessionFile;
+        this.agent.kill();
+        this.reverseStartTime = Date.now();
+        this.preReverseSessionFile = sessionFile;
+        log('reverse', {
+            context_count: this.recorder.context.length,
+            session: sessionFile || null,
+        });
+        if (sessionFile) {
+            this.fifoWrite(`SESSION:${sessionFile}`);
+        }
+        else {
+            this.fifoWrite('SESSION:');
+        }
+    }
+    async handleReverseDone() {
+        this.debugLog('EVENT: reverse_done');
+        const since = Math.max(this.reverseStartTime, this.sessionEpoch);
+        const recovered = await findLatestSession(since, (...a) => this.debugLog(...a));
+        this.agent.sessionFile = recovered ?? this.preReverseSessionFile;
+        log('reverse_done', { session: this.agent.sessionFile ?? null });
+    }
+    // ═══════════════════════════════════════
+    // FIFO + debug
+    // ═══════════════════════════════════════
+    fifoWrite(data) {
+        if (this.fifoFd !== null) {
+            fs.writeSync(this.fifoFd, `${data}\n`);
+            this.debugLog('FIFO wrote:', data);
+        }
+        else {
+            this.debugLog('FIFO not ready, dropping:', data);
+        }
+    }
+    debugLog(...args) {
+        if (this.debugFd !== null) {
+            const ts = new Date().toISOString().slice(11, 23);
+            fs.writeSync(this.debugFd, `[${ts}] PISH ${args.map(String).join(' ')}\n`);
+        }
+    }
+}

package/dist/config.js

@@ -0,0 +1,187 @@
+/**
+ * Unified configuration.
+ *
+ * Priority: CLI args > ENV > defaults.
+ * All tunable parameters live here; other modules access via cfg.xxx.
+ */
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+// ── Defaults ──
+export const DEFAULTS = {
+    shell: 'bash',
+    maxContext: 20,
+    headLines: 50,
+    tailLines: 30,
+    lineWidth: 512,
+    toolResultLines: 10,
+};
+// ── Version ──
+function readVersion() {
+    try {
+        return require('../package.json').version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+// ── Parse helpers ──
+export function envInt(key, fallback) {
+    const v = process.env[key];
+    if (!v)
+        return fallback;
+    const n = parseInt(v, 10);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+/**
+ * Resolve a binary name or path to its full path.
+ * Contains '/' → validate as path; otherwise → which lookup.
+ * Returns null if not found.
+ */
+export function resolveBinary(nameOrPath) {
+    if (nameOrPath.includes('/')) {
+        try {
+            fs.accessSync(nameOrPath, fs.constants.X_OK);
+            return nameOrPath;
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        return execFileSync('which', [nameOrPath], {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/** Infer shell type from binary path basename. */
+export function inferShellType(shellPath) {
+    const base = shellPath.split('/').pop() ?? '';
+    if (base === 'bash' || base.startsWith('bash'))
+        return 'bash';
+    if (base === 'zsh' || base.startsWith('zsh'))
+        return 'zsh';
+    return null;
+}
+export function parseArgs(argv) {
+    const args = argv.slice(2); // skip node, script
+    const result = { noAgent: false, help: false, version: false };
+    let i = 0;
+    while (i < args.length) {
+        const a = args[i];
+        if (a === '--help' || a === '-h') {
+            result.help = true;
+        }
+        else if (a === '--version' || a === '-v') {
+            result.version = true;
+        }
+        else if (a === '--shell' || a === '-s') {
+            result.shell = args[++i];
+        }
+        else if (a.startsWith('--shell=')) {
+            result.shell = a.slice('--shell='.length);
+        }
+        else if (a === '--pi') {
+            result.pi = args[++i];
+        }
+        else if (a.startsWith('--pi=')) {
+            result.pi = a.slice('--pi='.length);
+        }
+        else if (a === '--no-agent') {
+            result.noAgent = true;
+        }
+        else if (!a.startsWith('-') && !result.shell) {
+            // Positional argument = shell
+            result.shell = a;
+        }
+        i++;
+    }
+    return result;
+}
+// ── Help ──
+function printHelp(version) {
+    process.stderr.write(`pish v${version} — Pi-Integrated Shell
+
+Usage: pish [options] [shell]
+
+Arguments:
+  shell               bash, zsh, or path (default: bash)
+
+Options:
+  -s, --shell <name>  Shell name or path
+  --pi <path>         Path to pi binary (default: pi in PATH)
+  --no-agent          Disable agent (CNF passes through, for debugging)
+  -v, --version       Show version
+  -h, --help          Show help
+
+Environment variables:
+  PISH_SHELL          Shell name or path (default: $SHELL or bash)
+  PISH_PI             Path to pi binary
+  PISH_MAX_CONTEXT    Max context entries (default: ${DEFAULTS.maxContext})
+  PISH_HEAD_LINES     Output head lines (default: ${DEFAULTS.headLines})
+  PISH_TAIL_LINES     Output tail lines (default: ${DEFAULTS.tailLines})
+  PISH_LINE_WIDTH     Max line width (default: ${DEFAULTS.lineWidth})
+  PISH_TOOL_LINES     Tool result lines (default: ${DEFAULTS.toolResultLines})
+  PISH_LOG            Event log (stderr or file path)
+  PISH_DEBUG          Debug log file path
+  PISH_NO_BANNER      Hide startup banner (set to 1)
+
+Priority: CLI args > ENV > defaults
+`);
+}
+// ── Entry point ──
+export function loadConfig() {
+    const cli = parseArgs(process.argv);
+    const version = readVersion();
+    if (cli.help) {
+        printHelp(version);
+        process.exit(0);
+    }
+    if (cli.version) {
+        process.stderr.write(`pish v${version}\n`);
+        process.exit(0);
+    }
+    // ── Shell resolution (CLI > ENV > default) ──
+    const shellSpec = cli.shell ?? process.env.PISH_SHELL ?? process.env.SHELL ?? DEFAULTS.shell;
+    const shellPath = resolveBinary(shellSpec);
+    if (!shellPath) {
+        process.stderr.write(`pish: shell not found: ${shellSpec}\n`);
+        process.exit(1);
+    }
+    const shell = inferShellType(shellPath);
+    if (!shell) {
+        process.stderr.write(`pish: unsupported shell: ${shellSpec} (only bash and zsh)\n`);
+        process.exit(1);
+    }
+    // ── Pi resolution (skipped in --no-agent mode) ──
+    const noAgent = cli.noAgent;
+    let piPath = '';
+    if (!noAgent) {
+        const piSpec = cli.pi ?? process.env.PISH_PI ?? 'pi';
+        const resolved = resolveBinary(piSpec);
+        if (!resolved) {
+            process.stderr.write(`pish: pi not found: ${piSpec}\n`);
+            process.stderr.write(`  Install pi or set --pi <path> / PISH_PI\n`);
+            process.exit(1);
+        }
+        piPath = resolved;
+    }
+    return {
+        shell,
+        shellPath,
+        piPath,
+        version,
+        noAgent,
+        maxContext: envInt('PISH_MAX_CONTEXT', DEFAULTS.maxContext),
+        headLines: envInt('PISH_HEAD_LINES', DEFAULTS.headLines),
+        tailLines: envInt('PISH_TAIL_LINES', DEFAULTS.tailLines),
+        lineWidth: envInt('PISH_LINE_WIDTH', DEFAULTS.lineWidth),
+        toolResultLines: envInt('PISH_TOOL_LINES', DEFAULTS.toolResultLines),
+        noBanner: process.env.PISH_NO_BANNER === '1',
+    };
+}