@blockrun/runcode 2.1.0 → 2.2.0

package/dist/agent/commands.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Slash command registry for runcode.
+ * Extracted from loop.ts for maintainability.
+ *
+ * Two types of commands:
+ * 1. "Handled" — execute directly, emit events, return { handled: true }
+ * 2. "Rewrite" — transform input into a prompt for the agent, return { handled: false, rewritten }
+ */
+import type { ModelClient } from './llm.js';
+import type { AgentConfig, Dialogue, StreamEvent } from './types.js';
+type EventEmitter = (event: StreamEvent) => void;
+interface CommandContext {
+    history: Dialogue[];
+    config: AgentConfig;
+    client: ModelClient;
+    sessionId: string;
+    onEvent: EventEmitter;
+}
+interface CommandResult {
+    handled: boolean;
+    rewritten?: string;
+}
+/**
+ * Handle a slash command. Returns result indicating what happened.
+ */
+export declare function handleSlashCommand(input: string, ctx: CommandContext): Promise<CommandResult>;
+export {};

package/dist/agent/commands.js

@@ -0,0 +1,276 @@
+/**
+ * Slash command registry for runcode.
+ * Extracted from loop.ts for maintainability.
+ *
+ * Two types of commands:
+ * 1. "Handled" — execute directly, emit events, return { handled: true }
+ * 2. "Rewrite" — transform input into a prompt for the agent, return { handled: false, rewritten }
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { BLOCKRUN_DIR, VERSION } from '../config.js';
+import { estimateHistoryTokens, getAnchoredTokenCount, getContextWindow, resetTokenAnchor } from './tokens.js';
+import { forceCompact } from './compact.js';
+import { listSessions, loadSessionHistory, } from '../session/storage.js';
+// ─── Git helpers ──────────────────────────────────────────────────────────
+function gitExec(cmd, cwd, timeout = 5000, maxBuffer) {
+    return execSync(cmd, {
+        cwd,
+        encoding: 'utf-8',
+        timeout,
+        maxBuffer: maxBuffer || 1024 * 1024,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+}
+function gitCmd(ctx, cmd, timeout, maxBuffer) {
+    try {
+        return gitExec(cmd, ctx.config.workingDir || process.cwd(), timeout, maxBuffer);
+    }
+    catch (e) {
+        ctx.onEvent({ kind: 'text_delta', text: `Git error: ${e.message?.split('\n')[0] || 'unknown'}\n` });
+        return null;
+    }
+}
+function emitDone(ctx) {
+    ctx.onEvent({ kind: 'turn_done', reason: 'completed' });
+}
+// ─── Command Definitions ──────────────────────────────────────────────────
+// Direct-handled commands (don't go to agent)
+const DIRECT_COMMANDS = {
+    '/stash': (ctx) => {
+        const r = gitCmd(ctx, 'git stash push -m "runcode auto-stash"', 10000);
+        if (r !== null)
+            ctx.onEvent({ kind: 'text_delta', text: r || 'No changes to stash.\n' });
+        emitDone(ctx);
+    },
+    '/unstash': (ctx) => {
+        const r = gitCmd(ctx, 'git stash pop', 10000);
+        if (r !== null)
+            ctx.onEvent({ kind: 'text_delta', text: r || 'Stash applied.\n' });
+        emitDone(ctx);
+    },
+    '/log': (ctx) => {
+        const r = gitCmd(ctx, 'git log --oneline -15 --no-color');
+        ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'No commits or not a git repo.\n' });
+        emitDone(ctx);
+    },
+    '/status': (ctx) => {
+        const r = gitCmd(ctx, 'git status --short --branch');
+        ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'Not a git repo.\n' });
+        emitDone(ctx);
+    },
+    '/diff': (ctx) => {
+        const r = gitCmd(ctx, 'git diff --stat && echo "---" && git diff', 10000, 512 * 1024);
+        ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`diff\n${r}\n\`\`\`\n` : 'No changes.\n' });
+        emitDone(ctx);
+    },
+    '/undo': (ctx) => {
+        const r = gitCmd(ctx, 'git reset --soft HEAD~1');
+        if (r !== null)
+            ctx.onEvent({ kind: 'text_delta', text: 'Last commit undone. Changes preserved in staging.\n' });
+        emitDone(ctx);
+    },
+    '/bug': (ctx) => {
+        ctx.onEvent({ kind: 'text_delta', text: 'Report issues at: https://github.com/BlockRunAI/runcode/issues\n' });
+        emitDone(ctx);
+    },
+    '/version': (ctx) => {
+        ctx.onEvent({ kind: 'text_delta', text: `RunCode v${VERSION}\n` });
+        emitDone(ctx);
+    },
+    '/mcp': async (ctx) => {
+        const { listMcpServers } = await import('../mcp/client.js');
+        const servers = listMcpServers();
+        if (servers.length === 0) {
+            ctx.onEvent({ kind: 'text_delta', text: 'No MCP servers connected.\nAdd servers to `~/.blockrun/mcp.json` or `.mcp.json` in your project.\n' });
+        }
+        else {
+            let text = `**${servers.length} MCP server(s) connected:**\n\n`;
+            for (const s of servers) {
+                text += `  **${s.name}** — ${s.toolCount} tools\n`;
+                for (const t of s.tools)
+                    text += `    · ${t}\n`;
+            }
+            ctx.onEvent({ kind: 'text_delta', text });
+        }
+        emitDone(ctx);
+    },
+    '/context': async (ctx) => {
+        const { estimated, apiAnchored } = getAnchoredTokenCount(ctx.history);
+        const contextWindow = getContextWindow(ctx.config.model);
+        const usagePct = ((estimated / contextWindow) * 100).toFixed(1);
+        ctx.onEvent({ kind: 'text_delta', text: `**Session Context**\n` +
+                `  Model:      ${ctx.config.model}\n` +
+                `  Mode:       ${ctx.config.permissionMode || 'default'}\n` +
+                `  Messages:   ${ctx.history.length}\n` +
+                `  Tokens:     ~${estimated.toLocaleString()} / ${(contextWindow / 1000).toFixed(0)}k (${usagePct}%)${apiAnchored ? ' ✓' : ' ~'}\n` +
+                `  Session:    ${ctx.sessionId}\n` +
+                `  Directory:  ${ctx.config.workingDir || process.cwd()}\n`
+        });
+        emitDone(ctx);
+    },
+    '/doctor': (ctx) => {
+        const checks = [];
+        try {
+            execSync('git --version', { stdio: 'pipe' });
+            checks.push('✓ git available');
+        }
+        catch {
+            checks.push('✗ git not found');
+        }
+        try {
+            execSync('rg --version', { stdio: 'pipe' });
+            checks.push('✓ ripgrep available');
+        }
+        catch {
+            checks.push('⚠ ripgrep not found (using native grep fallback)');
+        }
+        checks.push(fs.existsSync(path.join(BLOCKRUN_DIR, 'wallet.json')) ? '✓ wallet configured' : '⚠ no wallet — run: runcode setup');
+        checks.push(fs.existsSync(path.join(BLOCKRUN_DIR, 'runcode-config.json')) ? '✓ config file exists' : '⚠ no config — using defaults');
+        checks.push(`✓ model: ${ctx.config.model}`);
+        checks.push(`✓ history: ${ctx.history.length} messages, ~${estimateHistoryTokens(ctx.history).toLocaleString()} tokens`);
+        checks.push(`✓ session: ${ctx.sessionId}`);
+        checks.push(`✓ version: v${VERSION}`);
+        ctx.onEvent({ kind: 'text_delta', text: `**Health Check**\n${checks.map(c => '  ' + c).join('\n')}\n` });
+        emitDone(ctx);
+    },
+    '/plan': (ctx) => {
+        if (ctx.config.permissionMode === 'plan') {
+            ctx.onEvent({ kind: 'text_delta', text: 'Already in plan mode. Use /execute to exit.\n' });
+        }
+        else {
+            ctx.config.permissionMode = 'plan';
+            ctx.onEvent({ kind: 'text_delta', text: '**Plan mode active.** Tools restricted to read-only. Use /execute when ready to implement.\n' });
+        }
+        emitDone(ctx);
+    },
+    '/execute': (ctx) => {
+        if (ctx.config.permissionMode !== 'plan') {
+            ctx.onEvent({ kind: 'text_delta', text: 'Not in plan mode. Use /plan to enter.\n' });
+        }
+        else {
+            ctx.config.permissionMode = 'default';
+            ctx.onEvent({ kind: 'text_delta', text: '**Execution mode.** All tools enabled with permissions.\n' });
+        }
+        emitDone(ctx);
+    },
+    '/sessions': (ctx) => {
+        const sessions = listSessions();
+        if (sessions.length === 0) {
+            ctx.onEvent({ kind: 'text_delta', text: 'No saved sessions.\n' });
+        }
+        else {
+            let text = `**${sessions.length} saved sessions:**\n\n`;
+            for (const s of sessions.slice(0, 10)) {
+                const date = new Date(s.updatedAt).toLocaleString();
+                const dir = s.workDir ? ` — ${s.workDir.split('/').pop()}` : '';
+                text += `  ${s.id}  ${s.model}  ${s.turnCount} turns  ${date}${dir}\n`;
+            }
+            if (sessions.length > 10)
+                text += `  ... and ${sessions.length - 10} more\n`;
+            text += '\nUse /resume <session-id> to continue a session.\n';
+            ctx.onEvent({ kind: 'text_delta', text });
+        }
+        emitDone(ctx);
+    },
+    '/compact': async (ctx) => {
+        const beforeTokens = estimateHistoryTokens(ctx.history);
+        const { history: compacted, compacted: didCompact } = await forceCompact(ctx.history, ctx.config.model, ctx.client, ctx.config.debug);
+        if (didCompact) {
+            ctx.history.length = 0;
+            ctx.history.push(...compacted);
+            resetTokenAnchor();
+        }
+        const afterTokens = estimateHistoryTokens(ctx.history);
+        ctx.onEvent({ kind: 'text_delta', text: didCompact
+                ? `Compacted: ~${beforeTokens.toLocaleString()} → ~${afterTokens.toLocaleString()} tokens\n`
+                : `History too short to compact (${beforeTokens.toLocaleString()} tokens, ${ctx.history.length} messages).\n`
+        });
+        emitDone(ctx);
+    },
+};
+// Prompt-rewrite commands (transformed into agent prompts)
+const REWRITE_COMMANDS = {
+    '/commit': 'Review the current git diff and staged changes. Stage relevant files with `git add`, then create a commit with a concise message summarizing the changes. Do NOT push to remote.',
+    '/push': 'Push the current branch to the remote repository using `git push`. Show the result.',
+    '/pr': 'Create a pull request for the current branch. First check `git log --oneline main..HEAD` to see commits, then use `gh pr create` with a descriptive title and body summarizing the changes. If gh CLI is not available, show the manual steps.',
+    '/review': 'Review the current git diff. For each changed file, check for: bugs, security issues, missing error handling, performance problems, and style issues. Provide a brief summary of findings.',
+    '/fix': 'Look at the most recent error or issue we discussed and fix it. Check the relevant files, identify the root cause, and apply the fix.',
+    '/test': 'Detect the project test framework (look for package.json scripts, pytest, etc.) and run the test suite. Show a summary of results.',
+    '/debug': 'Look at the most recent error in this session. Read the relevant source files, analyze the root cause, and suggest a fix with specific code changes.',
+    '/init': 'Read the project structure: check package.json (or equivalent), README, and key config files. Summarize: what this project is, main language/framework, entry points, and how to run/test it.',
+    '/todo': 'Search the codebase for TODO, FIXME, HACK, and XXX comments using Grep. Show the results grouped by file.',
+    '/deps': 'Read the project dependency file (package.json, requirements.txt, go.mod, Cargo.toml, etc.) and list key dependencies with their versions.',
+    '/optimize': 'Analyze the codebase for performance issues. Check for: unnecessary re-renders, N+1 queries, missing indexes, unoptimized loops, large bundle sizes, and memory leaks. Provide specific recommendations.',
+    '/security': 'Audit the codebase for security issues. Check for: SQL injection, XSS, command injection, hardcoded secrets, insecure dependencies, OWASP top 10 vulnerabilities. Report findings with severity.',
+    '/lint': 'Check for code quality issues: unused imports, inconsistent naming, missing type annotations, long functions, duplicated code. Suggest improvements.',
+    '/migrate': 'Check for pending database migrations, outdated dependencies, or breaking changes that need addressing. List required migration steps.',
+    '/clean': 'Find and remove dead code: unused imports, unreachable code, commented-out blocks, unused variables and functions. Show what would be removed before making changes.',
+    '/tasks': 'List all current tasks using the Task tool.',
+};
+// Commands with arguments (prefix match → rewrite)
+const ARG_COMMANDS = [
+    { prefix: '/explain ', rewrite: (a) => `Read and explain the code in ${a}. Cover: what it does, key functions/classes, how it connects to the rest of the codebase.` },
+    { prefix: '/search ', rewrite: (a) => `Search the codebase for "${a}" using Grep. Show the matching files and relevant code context.` },
+    { prefix: '/find ', rewrite: (a) => `Find files matching the pattern "${a}" using Glob. Show the results.` },
+    { prefix: '/refactor ', rewrite: (a) => `Refactor: ${a}. Read the relevant code first, then make targeted changes. Explain each change.` },
+    { prefix: '/scaffold ', rewrite: (a) => `Create the scaffolding/boilerplate for: ${a}. Generate the file structure and initial code. Ask me if you need clarification on requirements.` },
+    { prefix: '/doc ', rewrite: (a) => `Generate documentation for ${a}. Include: purpose, API/interface description, usage examples, and important notes.` },
+];
+// ─── Main dispatch ────────────────────────────────────────────────────────
+/**
+ * Handle a slash command. Returns result indicating what happened.
+ */
+export async function handleSlashCommand(input, ctx) {
+    // Direct-handled commands
+    if (input in DIRECT_COMMANDS) {
+        await DIRECT_COMMANDS[input](ctx);
+        return { handled: true };
+    }
+    // /branch has both no-arg and with-arg forms
+    if (input === '/branch' || input.startsWith('/branch ')) {
+        const cwd = ctx.config.workingDir || process.cwd();
+        if (input === '/branch') {
+            const r = gitCmd(ctx, 'git branch -v --no-color');
+            ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'Not a git repo.\n' });
+        }
+        else {
+            const branchName = input.slice(8).trim();
+            const r = gitCmd(ctx, `git checkout -b ${branchName}`);
+            if (r !== null)
+                ctx.onEvent({ kind: 'text_delta', text: `Created and switched to branch: **${branchName}**\n` });
+        }
+        emitDone(ctx);
+        return { handled: true };
+    }
+    // /resume <id>
+    if (input.startsWith('/resume ')) {
+        const targetId = input.slice(8).trim();
+        const restored = loadSessionHistory(targetId);
+        if (restored.length === 0) {
+            ctx.onEvent({ kind: 'text_delta', text: `Session "${targetId}" not found or empty.\n` });
+        }
+        else {
+            ctx.history.length = 0;
+            ctx.history.push(...restored);
+            resetTokenAnchor();
+            ctx.onEvent({ kind: 'text_delta', text: `Restored ${restored.length} messages from ${targetId}. Continue where you left off.\n` });
+        }
+        emitDone(ctx);
+        return { handled: true };
+    }
+    // Simple rewrite commands (exact match)
+    if (input in REWRITE_COMMANDS) {
+        return { handled: false, rewritten: REWRITE_COMMANDS[input] };
+    }
+    // Argument-based rewrite commands (prefix match)
+    for (const { prefix, rewrite } of ARG_COMMANDS) {
+        if (input.startsWith(prefix)) {
+            const arg = input.slice(prefix.length).trim();
+            return { handled: false, rewritten: rewrite(arg) };
+        }
+    }
+    // Not a recognized command
+    return { handled: false };
+}

package/dist/agent/llm.js

@@ -294,8 +294,11 @@ export class ModelClient {
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });
-                // Safety: if buffer grows too large without newlines, truncate
+                // Safety: if buffer grows too large without newlines, something is wrong
                 if (buffer.length > MAX_BUFFER) {
+                    if (this.debug) {
+                        console.error(`[runcode] SSE buffer overflow (${(buffer.length / 1024).toFixed(0)}KB) — truncating to prevent OOM`);
+                    }
                     buffer = buffer.slice(-MAX_BUFFER / 2);
                 }
                 const lines = buffer.split('\n');

package/dist/agent/loop.js

@@ -4,17 +4,15 @@
  * Original implementation with different architecture from any reference codebase.
  */
 import { ModelClient } from './llm.js';
-import { autoCompactIfNeeded, forceCompact, microCompact } from './compact.js';
+import { autoCompactIfNeeded, microCompact } from './compact.js';
 import { estimateHistoryTokens, updateActualTokens, resetTokenAnchor } from './tokens.js';
+import { handleSlashCommand } from './commands.js';
 import { PermissionManager } from './permissions.js';
 import { StreamingExecutor } from './streaming-executor.js';
 import { optimizeHistory, CAPPED_MAX_TOKENS, ESCALATED_MAX_TOKENS } from './optimize.js';
 import { recordUsage } from '../stats/tracker.js';
 import { estimateCost } from '../pricing.js';
-import fs from 'node:fs';
-import path from 'node:path';
-import { BLOCKRUN_DIR, VERSION } from '../config.js';
-import { createSessionId, appendToSession, updateSessionMeta, pruneOldSessions, listSessions, loadSessionHistory, } from '../session/storage.js';
+import { createSessionId, appendToSession, updateSessionMeta, pruneOldSessions, } from '../session/storage.js';
 // ─── Main Entry Point ──────────────────────────────────────────────────────
 /**
  * Run the agent loop.
@@ -222,378 +220,15 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             break; // User wants to exit
         if (input === '')
             continue; // Empty input → re-prompt
-        // Handle /stash and /unstash — git stash management
-        if (input === '/stash') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const result = execSync('git stash push -m "runcode auto-stash"', {
-                    cwd: config.workingDir || process.cwd(), encoding: 'utf-8', timeout: 10000
-                }).trim();
-                onEvent({ kind: 'text_delta', text: result || 'No changes to stash.\n' });
-            }
-            catch (e) {
-                onEvent({ kind: 'text_delta', text: `Stash error: ${e.message?.split('\n')[0]}\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        if (input === '/unstash') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const result = execSync('git stash pop', {
-                    cwd: config.workingDir || process.cwd(), encoding: 'utf-8', timeout: 10000
-                }).trim();
-                onEvent({ kind: 'text_delta', text: result || 'Stash applied.\n' });
-            }
-            catch (e) {
-                onEvent({ kind: 'text_delta', text: `Unstash error: ${e.message?.split('\n')[0]}\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /branch — show current branch or create new
-        if (input === '/branch' || input.startsWith('/branch ')) {
-            try {
-                const { execSync } = await import('node:child_process');
-                const cwd = config.workingDir || process.cwd();
-                if (input === '/branch') {
-                    const branches = execSync('git branch -v --no-color', { cwd, encoding: 'utf-8', timeout: 5000 }).trim();
-                    onEvent({ kind: 'text_delta', text: `\`\`\`\n${branches}\n\`\`\`\n` });
-                }
-                else {
-                    const branchName = input.slice(8).trim();
-                    execSync(`git checkout -b ${branchName}`, { cwd, encoding: 'utf-8', timeout: 5000 });
-                    onEvent({ kind: 'text_delta', text: `Created and switched to branch: **${branchName}**\n` });
-                }
-            }
-            catch (e) {
-                onEvent({ kind: 'text_delta', text: `Git error: ${e.message?.split('\n')[0] || 'unknown'}\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /log — show recent git log
-        if (input === '/log') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const log = execSync('git log --oneline -15 --no-color', {
-                    cwd: config.workingDir || process.cwd(), encoding: 'utf-8', timeout: 5000
-                }).trim();
-                onEvent({ kind: 'text_delta', text: log ? `\`\`\`\n${log}\n\`\`\`\n` : 'No commits.\n' });
-            }
-            catch {
-                onEvent({ kind: 'text_delta', text: 'Not a git repo.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /mcp — show connected MCP servers
-        if (input === '/mcp') {
-            const { listMcpServers } = await import('../mcp/client.js');
-            const servers = listMcpServers();
-            if (servers.length === 0) {
-                onEvent({ kind: 'text_delta', text: 'No MCP servers connected.\nAdd servers to `~/.blockrun/mcp.json` or `.mcp.json` in your project.\n' });
-            }
-            else {
-                let text = `**${servers.length} MCP server(s) connected:**\n\n`;
-                for (const s of servers) {
-                    text += `  **${s.name}** — ${s.toolCount} tools\n`;
-                    for (const t of s.tools) {
-                        text += `    · ${t}\n`;
-                    }
-                }
-                onEvent({ kind: 'text_delta', text });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /bug — open issue tracker
-        if (input === '/bug') {
-            onEvent({ kind: 'text_delta', text: 'Report issues at: https://github.com/BlockRunAI/runcode/issues\n' });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /version — show version
-        if (input === '/version') {
-            onEvent({ kind: 'text_delta', text: `RunCode v${VERSION}\n` });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /tasks — show task list (shortcut for Task list action)
-        if (input === '/tasks') {
-            input = 'List all current tasks using the Task tool.';
-        }
-        // Handle /doctor — diagnose setup issues
-        if (input === '/doctor') {
-            const checks = [];
-            const { execSync } = await import('node:child_process');
-            // Check git
-            try {
-                execSync('git --version', { stdio: 'pipe' });
-                checks.push('✓ git available');
-            }
-            catch {
-                checks.push('✗ git not found');
-            }
-            // Check rg
-            try {
-                execSync('rg --version', { stdio: 'pipe' });
-                checks.push('✓ ripgrep available');
-            }
-            catch {
-                checks.push('⚠ ripgrep not found (using native grep fallback)');
-            }
-            // Check wallet
-            const walletFile = path.join(BLOCKRUN_DIR, 'wallet.json');
-            checks.push(fs.existsSync(walletFile) ? '✓ wallet configured' : '⚠ no wallet — run: runcode setup');
-            // Check config
-            const configFile = path.join(BLOCKRUN_DIR, 'runcode-config.json');
-            checks.push(fs.existsSync(configFile) ? '✓ config file exists' : '⚠ no config — using defaults');
-            // Model & tokens
-            checks.push(`✓ model: ${config.model}`);
-            checks.push(`✓ history: ${history.length} messages, ~${estimateHistoryTokens(history).toLocaleString()} tokens`);
-            checks.push(`✓ session: ${sessionId}`);
-            checks.push(`✓ version: v${VERSION}`);
-            onEvent({ kind: 'text_delta', text: `**Health Check**\n${checks.map(c => '  ' + c).join('\n')}\n` });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /commit — rewrite as a prompt for the agent
-        if (input === '/commit') {
-            input = 'Review the current git diff and staged changes. Stage relevant files with `git add`, then create a commit with a concise message summarizing the changes. Do NOT push to remote.';
-        }
-        // Handle /undo — undo last commit (keep changes)
-        if (input === '/undo') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const result = execSync('git reset --soft HEAD~1', {
-                    cwd: config.workingDir || process.cwd(), encoding: 'utf-8', timeout: 5000
-                }).trim();
-                onEvent({ kind: 'text_delta', text: result || 'Last commit undone. Changes preserved in staging.\n' });
-            }
-            catch (e) {
-                onEvent({ kind: 'text_delta', text: `Undo error: ${e.message?.split('\n')[0]}\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /push — push to remote
-        if (input === '/push') {
-            input = 'Push the current branch to the remote repository using `git push`. Show the result.';
-        }
-        // Handle /pr — create pull request
-        if (input === '/pr') {
-            input = 'Create a pull request for the current branch. First check `git log --oneline main..HEAD` to see commits, then use `gh pr create` with a descriptive title and body summarizing the changes. If gh CLI is not available, show the manual steps.';
-        }
-        // Handle /review — ask agent to review current changes
-        if (input === '/review') {
-            input = 'Review the current git diff. For each changed file, check for: bugs, security issues, missing error handling, performance problems, and style issues. Provide a brief summary of findings.';
-        }
-        // Handle /fix — ask agent to fix the last error or issue
-        if (input === '/fix') {
-            input = 'Look at the most recent error or issue we discussed and fix it. Check the relevant files, identify the root cause, and apply the fix.';
-        }
-        // Handle /test — run project tests
-        if (input === '/test') {
-            input = 'Detect the project test framework (look for package.json scripts, pytest, etc.) and run the test suite. Show a summary of results.';
-        }
-        // Handle /explain <file> — explain code
-        if (input.startsWith('/explain ')) {
-            const target = input.slice(9).trim();
-            input = `Read and explain the code in ${target}. Cover: what it does, key functions/classes, how it connects to the rest of the codebase.`;
-        }
-        // Handle /search <query> — search codebase
-        if (input.startsWith('/search ')) {
-            const query = input.slice(8).trim();
-            input = `Search the codebase for "${query}" using Grep. Show the matching files and relevant code context.`;
-        }
-        // Handle /find <pattern> — find files
-        if (input.startsWith('/find ')) {
-            const pattern = input.slice(6).trim();
-            input = `Find files matching the pattern "${pattern}" using Glob. Show the results.`;
-        }
-        // Handle /refactor <description> — code refactoring
-        if (input.startsWith('/refactor ')) {
-            const desc = input.slice(10).trim();
-            input = `Refactor: ${desc}. Read the relevant code first, then make targeted changes. Explain each change.`;
-        }
-        // Handle /debug — analyze recent error
-        if (input === '/debug') {
-            input = 'Look at the most recent error in this session. Read the relevant source files, analyze the root cause, and suggest a fix with specific code changes.';
-        }
-        // Handle /init — initialize project context
-        if (input === '/init') {
-            input = 'Read the project structure: check package.json (or equivalent), README, and key config files. Summarize: what this project is, main language/framework, entry points, and how to run/test it.';
-        }
-        // Handle /todo — find TODOs in codebase
-        if (input === '/todo') {
-            input = 'Search the codebase for TODO, FIXME, HACK, and XXX comments using Grep. Show the results grouped by file.';
-        }
-        // Handle /deps — show project dependencies
-        if (input === '/deps') {
-            input = 'Read the project dependency file (package.json, requirements.txt, go.mod, Cargo.toml, etc.) and list key dependencies with their versions.';
-        }
-        // Handle /scaffold <desc> — generate boilerplate
-        if (input.startsWith('/scaffold ')) {
-            const desc = input.slice(10).trim();
-            input = `Create the scaffolding/boilerplate for: ${desc}. Generate the file structure and initial code. Ask me if you need clarification on requirements.`;
-        }
-        // Handle /optimize — performance optimization
-        if (input === '/optimize') {
-            input = 'Analyze the codebase for performance issues. Check for: unnecessary re-renders, N+1 queries, missing indexes, unoptimized loops, large bundle sizes, and memory leaks. Provide specific recommendations.';
-        }
-        // Handle /security — security audit
-        if (input === '/security') {
-            input = 'Audit the codebase for security issues. Check for: SQL injection, XSS, command injection, hardcoded secrets, insecure dependencies, OWASP top 10 vulnerabilities. Report findings with severity.';
-        }
-        // Handle /lint — code quality
-        if (input === '/lint') {
-            input = 'Check for code quality issues: unused imports, inconsistent naming, missing type annotations, long functions, duplicated code. Suggest improvements.';
-        }
-        // Handle /doc <target> — generate documentation
-        if (input.startsWith('/doc ')) {
-            const target = input.slice(5).trim();
-            input = `Generate documentation for ${target}. Include: purpose, API/interface description, usage examples, and important notes.`;
-        }
-        // Handle /migrate — migration helper
-        if (input === '/migrate') {
-            input = 'Check for pending database migrations, outdated dependencies, or breaking changes that need addressing. List required migration steps.';
-        }
-        // Handle /clean — cleanup dead code
-        if (input === '/clean') {
-            input = 'Find and remove dead code: unused imports, unreachable code, commented-out blocks, unused variables and functions. Show what would be removed before making changes.';
-        }
-        // Handle /status — show git status
-        if (input === '/status') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const status = execSync('git status --short --branch', {
-                    cwd: config.workingDir || process.cwd(),
-                    encoding: 'utf-8',
-                    timeout: 5_000,
-                }).trim();
-                onEvent({ kind: 'text_delta', text: status ? `\`\`\`\n${status}\n\`\`\`\n` : 'No git status.\n' });
-            }
-            catch {
-                onEvent({ kind: 'text_delta', text: 'Not a git repo.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /diff — show git diff of current changes
-        if (input === '/diff') {
-            try {
-                const { execSync } = await import('node:child_process');
-                const diff = execSync('git diff --stat && echo "---" && git diff', {
-                    cwd: config.workingDir || process.cwd(),
-                    encoding: 'utf-8',
-                    timeout: 10_000,
-                    maxBuffer: 512 * 1024,
-                }).trim();
-                onEvent({ kind: 'text_delta', text: diff ? `\`\`\`diff\n${diff}\n\`\`\`\n` : 'No changes.\n' });
-            }
-            catch {
-                onEvent({ kind: 'text_delta', text: 'Not a git repository or git not available.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /context — show current session context info
-        if (input === '/context') {
-            const { getAnchoredTokenCount, getContextWindow } = await import('./tokens.js');
-            const { estimated, apiAnchored } = getAnchoredTokenCount(history);
-            const contextWindow = getContextWindow(config.model);
-            const usagePct = ((estimated / contextWindow) * 100).toFixed(1);
-            const msgs = history.length;
-            const model = config.model;
-            const dir = config.workingDir || process.cwd();
-            const mode = config.permissionMode || 'default';
-            onEvent({ kind: 'text_delta', text: `**Session Context**\n` +
-                    `  Model:      ${model}\n` +
-                    `  Mode:       ${mode}\n` +
-                    `  Messages:   ${msgs}\n` +
-                    `  Tokens:     ~${estimated.toLocaleString()} / ${(contextWindow / 1000).toFixed(0)}k (${usagePct}%)${apiAnchored ? ' ✓' : ' ~'}\n` +
-                    `  Session:    ${sessionId}\n` +
-                    `  Directory:  ${dir}\n`
+        // ── Slash command dispatch ──
+        if (input.startsWith('/')) {
+            const cmdResult = await handleSlashCommand(input, {
+                history, config, client, sessionId, onEvent,
             });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /plan — enter plan mode (restrict to read-only tools)
-        if (input === '/plan') {
-            if (config.permissionMode === 'plan') {
-                onEvent({ kind: 'text_delta', text: 'Already in plan mode. Use /execute to exit.\n' });
-            }
-            else {
-                config.permissionMode = 'plan';
-                onEvent({ kind: 'text_delta', text: '**Plan mode active.** Tools restricted to read-only. Use /execute when ready to implement.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /execute — exit plan mode
-        if (input === '/execute') {
-            if (config.permissionMode !== 'plan') {
-                onEvent({ kind: 'text_delta', text: 'Not in plan mode. Use /plan to enter.\n' });
-            }
-            else {
-                config.permissionMode = 'default';
-                onEvent({ kind: 'text_delta', text: '**Execution mode.** All tools enabled with permissions.\n' });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /sessions — list saved sessions
-        if (input === '/sessions') {
-            const sessions = listSessions();
-            if (sessions.length === 0) {
-                onEvent({ kind: 'text_delta', text: 'No saved sessions.\n' });
-            }
-            else {
-                let text = `**${sessions.length} saved sessions:**\n\n`;
-                for (const s of sessions.slice(0, 10)) {
-                    const date = new Date(s.updatedAt).toLocaleString();
-                    const dir = s.workDir ? ` — ${s.workDir.split('/').pop()}` : '';
-                    text += `  ${s.id}  ${s.model}  ${s.turnCount} turns  ${date}${dir}\n`;
-                }
-                if (sessions.length > 10)
-                    text += `  ... and ${sessions.length - 10} more\n`;
-                text += '\nUse /resume <session-id> to continue a session.\n';
-                onEvent({ kind: 'text_delta', text });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /resume <id> — restore session history
-        if (input.startsWith('/resume ')) {
-            const targetId = input.slice(8).trim();
-            const restored = loadSessionHistory(targetId);
-            if (restored.length === 0) {
-                onEvent({ kind: 'text_delta', text: `Session "${targetId}" not found or empty.\n` });
-            }
-            else {
-                history.length = 0;
-                history.push(...restored);
-                onEvent({ kind: 'text_delta', text: `Restored ${restored.length} messages from ${targetId}. Continue where you left off.\n` });
-            }
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
-        }
-        // Handle /compact command — force compaction without sending to model
-        if (input === '/compact') {
-            const beforeTokens = estimateHistoryTokens(history);
-            const { history: compacted, compacted: didCompact } = await forceCompact(history, config.model, client, config.debug);
-            if (didCompact) {
-                history.length = 0;
-                history.push(...compacted);
-            }
-            const afterTokens = estimateHistoryTokens(history);
-            onEvent({ kind: 'text_delta', text: didCompact
-                    ? `Compacted: ~${beforeTokens.toLocaleString()} → ~${afterTokens.toLocaleString()} tokens\n`
-                    : `History too short to compact (${beforeTokens.toLocaleString()} tokens, ${history.length} messages).\n`
-            });
-            onEvent({ kind: 'turn_done', reason: 'completed' });
-            continue;
+            if (cmdResult.handled)
+                continue;
+            if (cmdResult.rewritten)
+                input = cmdResult.rewritten;
         }
         history.push({ role: 'user', content: input });
         appendToSession(sessionId, { role: 'user', content: input });
@@ -635,7 +270,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             }
             const systemPrompt = config.systemInstructions.join('\n\n');
             let maxTokens = maxTokensOverride ?? CAPPED_MAX_TOKENS;
-            let responseParts;
+            let responseParts = [];
             let usage;
             let stopReason;
             // Create streaming executor for concurrent tool execution
@@ -672,6 +307,11 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             catch (err) {
                 // ── User abort (Esc key) ──
                 if (err.name === 'AbortError' || abort.signal.aborted) {
+                    // Save any partial response that was streamed before abort
+                    if (responseParts && responseParts.length > 0) {
+                        history.push({ role: 'assistant', content: responseParts });
+                        appendToSession(sessionId, { role: 'assistant', content: responseParts });
+                    }
                     onEvent({ kind: 'turn_done', reason: 'aborted' });
                     break;
                 }

package/dist/agent/optimize.js

@@ -64,15 +64,13 @@ export function budgetToolResults(history) {
                 messageTotal += PREVIEW_CHARS + 200;
                 continue;
             }
-            // Per-message aggregate cap
+            // Per-message aggregate cap — once exceeded, truncate remaining results
             if (messageTotal + size > MAX_TOOL_RESULTS_PER_MESSAGE_CHARS) {
                 modified = true;
-                const remaining = Math.max(0, MAX_TOOL_RESULTS_PER_MESSAGE_CHARS - messageTotal);
-                const preview = content.slice(0, Math.min(PREVIEW_CHARS, remaining));
                 budgeted.push({
                     type: 'tool_result',
                     tool_use_id: part.tool_use_id,
-                    content: `[Output omitted: message budget exceeded (${MAX_TOOL_RESULTS_PER_MESSAGE_CHARS / 1000}K chars/msg)]\n\n${preview}`,
+                    content: `[Output omitted: message budget exceeded (${MAX_TOOL_RESULTS_PER_MESSAGE_CHARS / 1000}K chars/msg)]`,
                     is_error: part.is_error,
                 });
                 messageTotal = MAX_TOOL_RESULTS_PER_MESSAGE_CHARS;

package/dist/tools/askuser.js

@@ -32,7 +32,7 @@ async function execute(input, _ctx) {
         });
         rl.on('close', () => {
             if (!answered)
-                resolve({ output: '(user skipped)' });
+                resolve({ output: 'User did not respond (EOF/piped input).', isError: true });
         });
     });
 }

package/dist/tools/glob.js

@@ -21,7 +21,7 @@ function globMatch(pattern, text) {
     return regex.test(text.replace(/\\/g, '/'));
 }
 function walkDirectory(dir, baseDir, pattern, results, depth, visited) {
-    if (depth > 20 || results.length >= MAX_RESULTS)
+    if (depth > 50 || results.length >= MAX_RESULTS)
         return;
     // Symlink loop protection
     const visitedSet = visited ?? new Set();

package/dist/tools/read.js

@@ -33,7 +33,7 @@ async function execute(input, ctx) {
         }
         const raw = fs.readFileSync(resolved, 'utf-8');
         const allLines = raw.split('\n');
-        const startLine = Math.max(0, (offset ?? 1) - 1);
+        const startLine = Math.max(0, (Math.max(1, offset ?? 1)) - 1);
         const maxLines = limit ?? 2000;
         const endLine = Math.min(allLines.length, startLine + maxLines);
         const slice = allLines.slice(startLine, endLine);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/runcode",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "RunCode — AI coding agent powered by 41+ models. Pay per use with USDC.",
   "type": "module",
   "bin": {