@researchcomputer/pista 0.1.2 → 0.1.3

package/dist/commands.js

@@ -1,31 +1,100 @@
 import { randomUUID } from 'node:crypto';
-import { describeConfig, parseCompatApiStyle, parsePermissionMode, parseThinkingLevel, } from './config.js';
+import { describeConfig, parseCompatApiStyle, parsePermissionMode, parseThinkingLevel } from './config.js';
 import { normalizeAgentName, normalizeEndpoint, errorMessage, saveApiKey, getApiKeyPath, getStoredApiKey, loadStoredPreferences, saveStoredPreferences, resolveConfiguredSkills, fetchGitHubSkill, fetchGitHubSkillIndex, } from './utils.js';
 const SLASH_COMMANDS = [
     { id: 'help', usage: '/help', description: 'Show this help message', allowWhileRunning: true, section: 'commands' },
     { id: 'init', usage: '/init', description: 'Analyze codebase and generate AGENTS.md', section: 'commands' },
     { id: 'name', usage: '/name [name]', description: 'Show or change agent name', section: 'commands' },
-    { id: 'abort', usage: '/abort', description: 'Stop current agent execution', allowWhileRunning: true, section: 'commands' },
+    {
+        id: 'abort',
+        usage: '/abort',
+        description: 'Stop current agent execution',
+        allowWhileRunning: true,
+        section: 'commands',
+    },
     { id: 'clear', usage: '/clear', description: 'Clear the terminal transcript', section: 'commands' },
     { id: 'reset', usage: '/reset', description: 'Reset agent conversation state', section: 'commands' },
     { id: 'cost', usage: '/cost', description: 'Show current session token usage', section: 'commands' },
     { id: 'key', usage: '/key', description: 'Update your stored API key', section: 'commands' },
-    { id: 'jump', usage: '/jump <target>', description: 'Jump transcript to latest | error | tool', insertText: '/jump ', section: 'commands' },
-    { id: 'permissions', usage: '/permissions', description: 'Change tool permission mode', aliases: ['permission-mode'], section: 'commands' },
+    {
+        id: 'jump',
+        usage: '/jump <target>',
+        description: 'Jump transcript to latest | error | tool',
+        insertText: '/jump ',
+        section: 'commands',
+    },
+    {
+        id: 'permissions',
+        usage: '/permissions',
+        description: 'Change tool permission mode',
+        aliases: ['permission-mode'],
+        section: 'commands',
+    },
     { id: 'thinking', usage: '/thinking', description: 'Change reasoning intensity', section: 'commands' },
+    {
+        id: 'btw',
+        usage: '/btw [message]',
+        description: "Start a side conversation that won't affect history (Esc to exit)",
+        insertText: '/btw ',
+        section: 'commands',
+    },
     { id: 'quit', usage: '/quit', description: 'Exit the application', aliases: ['exit'], section: 'commands' },
     { id: 'plugins', usage: '/plugins', description: 'List installed plugins', aliases: ['skills'], section: 'plugins' },
-    { id: 'plugins add', usage: '/plugins add', description: 'Add a new plugin (prompt or MCP)', insertText: '/plugins add ', section: 'plugins' },
-    { id: 'plugins install', usage: '/plugins install', description: 'Install from GitHub (owner/repo/path)', insertText: '/plugins install ', aliases: ['plugins add-github', 'plugins github'], section: 'plugins' },
-    { id: 'plugins browse', usage: '/plugins browse', description: 'Browse a GitHub skill repo', insertText: '/plugins browse ', section: 'plugins' },
-    { id: 'plugins remove', usage: '/plugins remove', description: 'Remove a plugin', insertText: '/plugins remove ', aliases: ['plugins rm'], section: 'plugins' },
-    { id: 'plugins enable', usage: '/plugins enable', description: 'Enable a disabled plugin', insertText: '/plugins enable ', section: 'plugins' },
-    { id: 'plugins disable', usage: '/plugins disable', description: 'Disable a plugin', insertText: '/plugins disable ', section: 'plugins' },
+    {
+        id: 'plugins add',
+        usage: '/plugins add',
+        description: 'Add a new plugin (prompt or MCP)',
+        insertText: '/plugins add ',
+        section: 'plugins',
+    },
+    {
+        id: 'plugins install',
+        usage: '/plugins install',
+        description: 'Install from GitHub (owner/repo/path)',
+        insertText: '/plugins install ',
+        aliases: ['plugins add-github', 'plugins github'],
+        section: 'plugins',
+    },
+    {
+        id: 'plugins browse',
+        usage: '/plugins browse',
+        description: 'Browse a GitHub skill repo',
+        insertText: '/plugins browse ',
+        section: 'plugins',
+    },
+    {
+        id: 'plugins remove',
+        usage: '/plugins remove',
+        description: 'Remove a plugin',
+        insertText: '/plugins remove ',
+        aliases: ['plugins rm'],
+        section: 'plugins',
+    },
+    {
+        id: 'plugins enable',
+        usage: '/plugins enable',
+        description: 'Enable a disabled plugin',
+        insertText: '/plugins enable ',
+        section: 'plugins',
+    },
+    {
+        id: 'plugins disable',
+        usage: '/plugins disable',
+        description: 'Disable a plugin',
+        insertText: '/plugins disable ',
+        section: 'plugins',
+    },
     { id: 'session', usage: '/session [new]', description: 'Show session info or start a fresh one', section: 'session' },
     { id: 'config', usage: '/config', description: 'Show current configuration', section: 'session' },
     { id: 'model', usage: '/model [id]', description: 'Change model id', section: 'model' },
     { id: 'endpoint', usage: '/endpoint [url]', description: 'Change API endpoint URL', section: 'model' },
-    { id: 'api', usage: '/api [style]', description: 'Set API style (chat or responses)', aliases: ['api-style'], section: 'model' },
+    {
+        id: 'api',
+        usage: '/api [style]',
+        description: 'Set API style (chat or responses)',
+        aliases: ['api-style'],
+        section: 'model',
+    },
 ];
 const SLASH_COMMAND_SECTION_TITLES = {
     commands: 'COMMANDS',
@@ -43,15 +112,10 @@ export function getSlashCommandSuggestions(input, running, limit = 6) {
     if (query === null)
         return [];
     const normalizedQuery = query.toLowerCase();
-    const candidates = SLASH_COMMANDS
-        .filter((item) => !running || item.allowWhileRunning)
+    const candidates = SLASH_COMMANDS.filter((item) => !running || item.allowWhileRunning)
         .map((item, index) => {
         const aliases = item.aliases ?? [];
-        const searchTerms = [
-            item.id,
-            item.usage.replace(/^\//, ''),
-            ...aliases,
-        ].map((term) => term.toLowerCase());
+        const searchTerms = [item.id, item.usage.replace(/^\//, ''), ...aliases].map((term) => term.toLowerCase());
         let rank = normalizedQuery ? 3 : 1;
         if (normalizedQuery) {
             if (searchTerms.some((term) => term === normalizedQuery)) {
@@ -166,16 +230,17 @@ export async function handleSlashCommand(input, ctx) {
         }
         case 'permissions':
         case 'permission-mode': {
-            const nextMode = args[0] ?? await ctx.openPicker({
-                title: 'Permission mode',
-                description: 'Choose how aggressively the agent may run tools.',
-                items: [
-                    { id: 'default', label: 'default', description: 'Ask when the SDK needs approval.' },
-                    { id: 'allowAll', label: 'allowAll', description: 'Allow all tool calls without prompts.' },
-                    { id: 'rulesOnly', label: 'rulesOnly', description: 'Allow only rules-backed tool calls, deny the rest.' },
-                ],
-                selectedId: config.permissionMode,
-            });
+            const nextMode = args[0] ??
+                (await ctx.openPicker({
+                    title: 'Permission mode',
+                    description: 'Choose how aggressively the agent may run tools.',
+                    items: [
+                        { id: 'default', label: 'default', description: 'Ask when the SDK needs approval.' },
+                        { id: 'allowAll', label: 'allowAll', description: 'Allow all tool calls without prompts.' },
+                        { id: 'rulesOnly', label: 'rulesOnly', description: 'Allow only rules-backed tool calls, deny the rest.' },
+                    ],
+                    selectedId: config.permissionMode,
+                }));
             if (!nextMode)
                 return;
             const parsedMode = parsePermissionMode(nextMode);
@@ -187,19 +252,20 @@ export async function handleSlashCommand(input, ctx) {
             return;
         }
         case 'thinking': {
-            const nextLevel = args[0] ?? await ctx.openPicker({
-                title: 'Thinking level',
-                description: 'Higher levels may improve answers, but they usually cost more and respond slower.',
-                items: [
-                    { id: 'off', label: 'off', description: 'No extra reasoning budget.' },
-                    { id: 'minimal', label: 'minimal', description: 'Small reasoning budget.' },
-                    { id: 'low', label: 'low', description: 'Low reasoning budget.' },
-                    { id: 'medium', label: 'medium', description: 'Balanced reasoning budget.' },
-                    { id: 'high', label: 'high', description: 'More deliberate reasoning.' },
-                    { id: 'xhigh', label: 'xhigh', description: 'Maximum reasoning budget.' },
-                ],
-                selectedId: config.thinkingLevel,
-            });
+            const nextLevel = args[0] ??
+                (await ctx.openPicker({
+                    title: 'Thinking level',
+                    description: 'Higher levels may improve answers, but they usually cost more and respond slower.',
+                    items: [
+                        { id: 'off', label: 'off', description: 'No extra reasoning budget.' },
+                        { id: 'minimal', label: 'minimal', description: 'Small reasoning budget.' },
+                        { id: 'low', label: 'low', description: 'Low reasoning budget.' },
+                        { id: 'medium', label: 'medium', description: 'Balanced reasoning budget.' },
+                        { id: 'high', label: 'high', description: 'More deliberate reasoning.' },
+                        { id: 'xhigh', label: 'xhigh', description: 'Maximum reasoning budget.' },
+                    ],
+                    selectedId: config.thinkingLevel,
+                }));
             if (!nextLevel)
                 return;
             const parsedLevel = parseThinkingLevel(nextLevel);
@@ -211,12 +277,13 @@ export async function handleSlashCommand(input, ctx) {
             return;
         }
         case 'name': {
-            const nextName = rest || await ctx.openPrompt({
-                title: 'Agent name',
-                description: 'Pick a short and cute name for this coding agent.',
-                initialValue: config.agentName,
-                placeholder: 'Example: Pista',
-            });
+            const nextName = rest ||
+                (await ctx.openPrompt({
+                    title: 'Agent name',
+                    description: 'Pick a short and cute name for this coding agent.',
+                    initialValue: config.agentName,
+                    placeholder: 'Example: Pista',
+                }));
             if (!nextName)
                 return;
             const normalizedName = normalizeAgentName(nextName);
@@ -230,18 +297,19 @@ export async function handleSlashCommand(input, ctx) {
                 try {
                     const apiKey = getStoredApiKey();
                     const response = await fetch(`${config.selection.endpoint}/models`, {
-                        headers: apiKey ? { 'Authorization': `Bearer ${apiKey}` } : {},
+                        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
                     });
                     if (response.ok) {
-                        const data = await response.json();
-                        const models = data.data.map(m => m.id);
+                        const data = (await response.json());
+                        const models = data.data.map((m) => m.id);
                         if (models.length > 0) {
-                            nextModel = await ctx.openPicker({
-                                title: 'Select Model',
-                                items: models.map(id => ({ id, label: id })),
-                                selectedId: config.selection.model,
-                                emptyMessage: 'No models returned from endpoint.',
-                            }) || '';
+                            nextModel =
+                                (await ctx.openPicker({
+                                    title: 'Select Model',
+                                    items: models.map((id) => ({ id, label: id })),
+                                    selectedId: config.selection.model,
+                                    emptyMessage: 'No models returned from endpoint.',
+                                })) || '';
                         }
                     }
                 }
@@ -269,11 +337,12 @@ export async function handleSlashCommand(input, ctx) {
             return;
         }
         case 'endpoint': {
-            const nextEndpoint = rest || await ctx.openPrompt({
-                title: 'API endpoint',
-                description: 'Example: https://api.research.computer/v1',
-                initialValue: config.selection.endpoint,
-            });
+            const nextEndpoint = rest ||
+                (await ctx.openPrompt({
+                    title: 'API endpoint',
+                    description: 'Example: https://api.research.computer/v1',
+                    initialValue: config.selection.endpoint,
+                }));
             if (!nextEndpoint)
                 return;
             try {
@@ -291,14 +360,15 @@ export async function handleSlashCommand(input, ctx) {
         }
         case 'api':
         case 'api-style': {
-            const nextStyle = args[0] ?? await ctx.openPicker({
-                title: 'Pick API style',
-                items: [
-                    { id: 'chat', label: 'chat', description: 'OpenAI-compatible chat/completions API' },
-                    { id: 'responses', label: 'responses', description: 'OpenAI-compatible responses API' },
-                ],
-                selectedId: config.selection.apiStyle,
-            });
+            const nextStyle = args[0] ??
+                (await ctx.openPicker({
+                    title: 'Pick API style',
+                    items: [
+                        { id: 'chat', label: 'chat', description: 'OpenAI-compatible chat/completions API' },
+                        { id: 'responses', label: 'responses', description: 'OpenAI-compatible responses API' },
+                    ],
+                    selectedId: config.selection.apiStyle,
+                }));
             if (!nextStyle)
                 return;
             const parsedStyle = parseCompatApiStyle(nextStyle);
@@ -379,11 +449,12 @@ export async function handleSlashCommand(input, ctx) {
                 return;
             }
             if (subcommand === 'add') {
-                const id = rest.slice(4).trim() || await ctx.openPrompt({
-                    title: 'Plugin ID',
-                    description: 'A unique identifier for this plugin (e.g. "typescript-style", "my-mcp-server").',
-                    placeholder: 'my-plugin',
-                });
+                const id = rest.slice(4).trim() ||
+                    (await ctx.openPrompt({
+                        title: 'Plugin ID',
+                        description: 'A unique identifier for this plugin (e.g. "typescript-style", "my-mcp-server").',
+                        placeholder: 'my-plugin',
+                    }));
                 if (!id)
                     return;
                 const description = await ctx.openPrompt({
@@ -411,7 +482,10 @@ export async function handleSlashCommand(input, ctx) {
                 if (description)
                     skill.description = description;
                 if (promptText) {
-                    skill.promptSections = promptText.split('\\n').map((s) => s.trim()).filter(Boolean);
+                    skill.promptSections = promptText
+                        .split('\\n')
+                        .map((s) => s.trim())
+                        .filter(Boolean);
                 }
                 if (mcpChoice !== 'no') {
                     const transport = mcpChoice;
@@ -428,12 +502,14 @@ export async function handleSlashCommand(input, ctx) {
                             description: 'Space-separated arguments for the command.',
                             placeholder: '-y @modelcontextprotocol/server-filesystem /',
                         });
-                        skill.mcpServers = [{
+                        skill.mcpServers = [
+                            {
                                 name: id.trim(),
                                 transport,
                                 command,
                                 args: argsStr ? argsStr.split(/\s+/) : [],
-                            }];
+                            },
+                        ];
                     }
                     else {
                         const url = await ctx.openPrompt({
@@ -464,11 +540,12 @@ export async function handleSlashCommand(input, ctx) {
                 return;
             }
             if (subcommand === 'add-github' || subcommand === 'github' || subcommand === 'install') {
-                const source = rest.slice(subcommand.length + 1).trim() || await ctx.openPrompt({
-                    title: 'GitHub source',
-                    description: 'Enter owner/repo or owner/repo/path/to/skill (e.g. "anthropics/skills/skills/pdf").',
-                    placeholder: 'anthropics/skills/skills/pdf',
-                });
+                const source = rest.slice(subcommand.length + 1).trim() ||
+                    (await ctx.openPrompt({
+                        title: 'GitHub source',
+                        description: 'Enter owner/repo or owner/repo/path/to/skill (e.g. "anthropics/skills/skills/pdf").',
+                        placeholder: 'anthropics/skills/skills/pdf',
+                    }));
                 if (!source)
                     return;
                 ctx.appendLog('system', 'Fetching plugin', `Downloading SKILL.md from ${source}...`);
@@ -503,11 +580,12 @@ export async function handleSlashCommand(input, ctx) {
                 return;
             }
             if (subcommand === 'browse') {
-                const source = rest.slice(7).trim() || await ctx.openPrompt({
-                    title: 'GitHub repository',
-                    description: 'Enter owner/repo to browse available skills (e.g. "anthropics/skills").',
-                    placeholder: 'anthropics/skills',
-                });
+                const source = rest.slice(7).trim() ||
+                    (await ctx.openPrompt({
+                        title: 'GitHub repository',
+                        description: 'Enter owner/repo to browse available skills (e.g. "anthropics/skills").',
+                        placeholder: 'anthropics/skills',
+                    }));
                 if (!source)
                     return;
                 const parts = source.replace(/https?:\/\/github\.com\//, '').split('/');
@@ -582,14 +660,15 @@ export async function handleSlashCommand(input, ctx) {
                     ctx.appendLog('system', 'Plugins', 'No plugins to remove.');
                     return;
                 }
-                const targetId = args[1] || await ctx.openPicker({
-                    title: 'Remove plugin',
-                    items: allSkills.map((s) => ({
-                        id: `${s.scope}:${s.id}`,
-                        label: `${s.id} [${s.scope}]`,
-                        description: s.description,
-                    })),
-                });
+                const targetId = args[1] ||
+                    (await ctx.openPicker({
+                        title: 'Remove plugin',
+                        items: allSkills.map((s) => ({
+                            id: `${s.scope}:${s.id}`,
+                            label: `${s.id} [${s.scope}]`,
+                            description: s.description,
+                        })),
+                    }));
                 if (!targetId)
                     return;
                 const [targetScope, ...idParts] = targetId.split(':');
@@ -615,19 +694,20 @@ export async function handleSlashCommand(input, ctx) {
                     ...(globalPrefs.skills ?? []).map((s) => ({ ...s, scope: 'global' })),
                     ...(projectPrefs.skills ?? []).map((s) => ({ ...s, scope: 'project' })),
                 ];
-                const filtered = allSkills.filter((s) => enabling ? s.enabled === false : s.enabled !== false);
+                const filtered = allSkills.filter((s) => (enabling ? s.enabled === false : s.enabled !== false));
                 if (filtered.length === 0) {
                     ctx.appendLog('system', 'Plugins', `No plugins to ${subcommand}.`);
                     return;
                 }
-                const targetId = args[1] || await ctx.openPicker({
-                    title: `${enabling ? 'Enable' : 'Disable'} plugin`,
-                    items: filtered.map((s) => ({
-                        id: `${s.scope}:${s.id}`,
-                        label: `${s.id} [${s.scope}]`,
-                        description: s.description,
-                    })),
-                });
+                const targetId = args[1] ||
+                    (await ctx.openPicker({
+                        title: `${enabling ? 'Enable' : 'Disable'} plugin`,
+                        items: filtered.map((s) => ({
+                            id: `${s.scope}:${s.id}`,
+                            label: `${s.id} [${s.scope}]`,
+                            description: s.description,
+                        })),
+                    }));
                 if (!targetId)
                     return;
                 const [targetScope, ...idParts] = targetId.split(':');
@@ -648,6 +728,22 @@ export async function handleSlashCommand(input, ctx) {
             ctx.appendLog('error', 'Unknown subcommand', `Usage: /plugins [list|add|install|browse|remove|enable|disable]`);
             return;
         }
+        case 'btw': {
+            if (ctx.isBtwActive()) {
+                ctx.appendLog('system', 'Already in btw mode', 'Press Esc to exit first.');
+                return;
+            }
+            if (rest) {
+                const entered = ctx.enterBtw(true);
+                if (entered) {
+                    await ctx.promptAgent(rest);
+                }
+            }
+            else {
+                ctx.enterBtw(false);
+            }
+            return;
+        }
         case 'quit':
         case 'exit':
             ctx.exit();

package/dist/commands.test.js

@@ -34,3 +34,40 @@ test('getSlashCommandSuggestions hides the popup once arguments are being typed'
 test('getSlashCommandSuggestions hides the popup after a completion adds a trailing space', () => {
     assert.deepEqual(getSlashCommandSuggestions('/plugins add ', false), []);
 });
+test('parseSlashCommand handles multi-word command', () => {
+    const result = parseSlashCommand('/plugins add my-plugin');
+    assert.equal(result.command, 'plugins');
+    assert.deepEqual(result.args, ['add', 'my-plugin']);
+    assert.equal(result.rest, 'add my-plugin');
+});
+test('parseSlashCommand lowercases command', () => {
+    const result = parseSlashCommand('/HELP');
+    assert.equal(result.command, 'help');
+});
+test('getSlashCommandSuggestions returns empty for non-slash input', () => {
+    const suggestions = getSlashCommandSuggestions('hello', false);
+    assert.equal(suggestions.length, 0);
+});
+test('getSlashCommandSuggestions filters by running state', () => {
+    const idle = getSlashCommandSuggestions('/h', false);
+    const running = getSlashCommandSuggestions('/h', true);
+    assert.ok(idle.length >= running.length);
+});
+test('getSlashCommandSuggestions respects limit', () => {
+    const suggestions = getSlashCommandSuggestions('/', false, 2);
+    assert.ok(suggestions.length <= 2);
+});
+test('getSlashCommandSuggestions includes btw', () => {
+    const suggestions = getSlashCommandSuggestions('/btw', false);
+    assert.ok(suggestions.some((s) => s.id === 'btw'));
+});
+test('parseSlashCommand parses /btw with message', () => {
+    const result = parseSlashCommand('/btw what is this function?');
+    assert.equal(result.command, 'btw');
+    assert.equal(result.rest, 'what is this function?');
+});
+test('parseSlashCommand parses /btw without message', () => {
+    const result = parseSlashCommand('/btw');
+    assert.equal(result.command, 'btw');
+    assert.equal(result.rest, '');
+});

package/dist/components/assistant-message-render.test.js

@@ -2,8 +2,18 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { renderMarkdownLines } from './assistant-message-render.js';
 test('renderMarkdownLines flattens common markdown formatting for terminal output', () => {
-    assert.deepEqual(renderMarkdownLines('# Title\n\nSee [docs](https://example.com) and **bold** text.'), ['Title', '', 'See docs (https://example.com) and bold text.']);
+    assert.deepEqual(renderMarkdownLines('# Title\n\nSee [docs](https://example.com) and **bold** text.'), [
+        'Title',
+        '',
+        'See docs (https://example.com) and bold text.',
+    ]);
 });
 test('renderMarkdownLines preserves code blocks while normalizing block syntax', () => {
-    assert.deepEqual(renderMarkdownLines('> note\n- item\n1. step\n---\n```ts\nconst value = 1;\n```'), ['| note', '• item', '1. step', '────────', 'const value = 1;']);
+    assert.deepEqual(renderMarkdownLines('> note\n- item\n1. step\n---\n```ts\nconst value = 1;\n```'), [
+        '| note',
+        '• item',
+        '1. step',
+        '────────',
+        'const value = 1;',
+    ]);
 });

package/dist/components/assistant-message.js

@@ -5,5 +5,5 @@ import { renderMarkdownLines } from './assistant-message-render.js';
 export const AssistantMessage = React.memo(function AssistantMessage({ content, showSpinner = false, spinner, }) {
     const body = content.trimEnd();
     const lines = renderMarkdownLines(body);
-    return (_jsxs(Box, { flexDirection: "column", children: [body ? lines.map((line, index) => (_jsx(Text, { children: line || ' ' }, index))) : _jsx(Text, { dimColor: true, children: "[no content]" }), showSpinner && spinner ? (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: " " }), spinner] })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [body ? lines.map((line, index) => _jsx(Text, { children: line || ' ' }, index)) : _jsx(Text, { dimColor: true, children: "[no content]" }), showSpinner && spinner ? (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: " " }), spinner] })) : null] }));
 });

package/dist/components/composer-panel.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import { Frame } from './frame.js';
+import { Editor } from './editor.js';
+import { SlashCommandMenu } from './slash-command-menu.js';
+export const ComposerPanel = React.memo(function ComposerPanel({ value, cursor, agentName, running, btwActive = false, slashMenuVisible, slashCommandItems, slashMenuSelectedIndex, termWidth, }) {
+    return (_jsxs(_Fragment, { children: [slashMenuVisible ? (_jsx(SlashCommandMenu, { items: slashCommandItems, selectedIndex: Math.min(slashMenuSelectedIndex, Math.max(0, slashCommandItems.length - 1)) })) : null, _jsx(Frame, { borderColor: btwActive ? 'magenta' : running ? 'yellow' : 'cyan', bottomLeft: slashMenuVisible
+                    ? 'Enter send · ⇧Enter newline · Tab complete · /help'
+                    : 'Enter send · ⇧Enter newline · /help', termWidth: termWidth, children: _jsxs(Box, { children: [_jsx(Text, { color: "greenBright", bold: true, children: '> ' }), _jsx(Editor, { value: value, cursor: cursor, placeholder: `Ask ${agentName} or type /help` })] }) })] }));
+});

package/dist/components/editor.js

@@ -16,7 +16,9 @@ export function editBuffer(current, input, key) {
     const chars = Array.from(current.value);
     let cursor = Math.max(0, Math.min(current.cursor, chars.length));
     const isBackspaceInput = input === '\x7f' || input === '\b' || input === '\x08' || (key.ctrl && input === 'h');
-    const shouldTreatDeleteAsBackspace = key.delete && !input && cursor === chars.length && cursor > 0;
+    // Many terminals report Backspace as key.delete with empty input.
+    // When key.delete fires with no input string, treat it as backspace.
+    const shouldTreatDeleteAsBackspace = key.delete && !input;
     const isBackspace = key.backspace || isBackspaceInput || shouldTreatDeleteAsBackspace;
     if (isBackspace) {
         if (cursor > 0) {
@@ -51,7 +53,7 @@ export function editBuffer(current, input, key) {
     }
     // Character insertion
     if (input && input.length > 0) {
-        const inputChars = Array.from(input).filter(c => {
+        const inputChars = Array.from(input).filter((c) => {
             const code = c.charCodeAt(0);
             return code >= 32 && code !== 127;
         });

package/dist/components/editor.test.js

@@ -30,10 +30,18 @@ test('delete at end of line behaves like backspace for terminals that map it tha
     const result = editBuffer({ value: 'abc', cursor: 3 }, '', key({ delete: true }));
     assert.deepEqual(result, { value: 'ab', cursor: 2 });
 });
-test('delete inside the line still removes the character at the cursor', () => {
-    const result = editBuffer({ value: 'abcd', cursor: 1 }, '', key({ delete: true }));
+test('key.delete with no input in the middle of the line acts as backspace', () => {
+    const result = editBuffer({ value: 'abcd', cursor: 2 }, '', key({ delete: true }));
     assert.deepEqual(result, { value: 'acd', cursor: 1 });
 });
+test('delete with no input inside the line acts as backspace', () => {
+    const result = editBuffer({ value: 'abcd', cursor: 1 }, '', key({ delete: true }));
+    assert.deepEqual(result, { value: 'bcd', cursor: 0 });
+});
+test('delete at cursor 0 with no input is a no-op', () => {
+    const result = editBuffer({ value: 'abcd', cursor: 0 }, '', key({ delete: true }));
+    assert.deepEqual(result, { value: 'abcd', cursor: 0 });
+});
 test('ctrl+key combinations are ignored by the editor buffer', () => {
     const result = editBuffer({ value: 'abcd', cursor: 2 }, 'p', key({ ctrl: true }));
     assert.deepEqual(result, { value: 'abcd', cursor: 2 });

package/dist/components/frame.js

@@ -1,19 +1,18 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { Box, Text } from 'ink';
-export const Frame = React.memo(function Frame({ children, borderColor, topLeft, topRight, bottomLeft, bottomRight, paddingX = 1, }) {
-    const termWidth = process.stdout.columns || 80;
-    const usableWidth = termWidth - 2; // account for outer padding in app
+export const Frame = React.memo(function Frame({ children, borderColor, topLeft, topRight, bottomLeft, bottomRight, paddingX = 1, termWidth, }) {
+    const usableWidth = (termWidth ?? 80) - 2; // account for outer padding in app
     return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(TopBorder, { width: usableWidth, color: borderColor, left: topLeft, right: topRight }), _jsx(Box, { flexDirection: "column", paddingX: paddingX, children: children }), _jsx(BottomBorder, { width: usableWidth, color: borderColor, left: bottomLeft, right: bottomRight })] }));
 });
-function TopBorder({ width, color, left, right }) {
+function TopBorder({ width, color, left, right, }) {
     const leftText = left ? ` ${left} ` : '';
     const rightText = right ? ` ${right} ` : '';
     const fillLen = Math.max(0, width - 3 - leftText.length - rightText.length);
     const fill = '─'.repeat(fillLen);
     return (_jsxs(Text, { color: color, children: ["\u256D\u2500", leftText, fill, rightText, "\u256E"] }));
 }
-function BottomBorder({ width, color, left, right }) {
+function BottomBorder({ width, color, left, right, }) {
     const leftText = left ? ` ${left} ` : '';
     const rightText = right ? ` ${right} ` : '';
     const fillLen = Math.max(0, width - 3 - leftText.length - rightText.length);

package/dist/components/header.js

@@ -47,9 +47,9 @@ export function formatPendingToolsLine(pendingTools, termWidth) {
     }
     return `▸ ${shown.join(', ')}`;
 }
-export const Header = React.memo(function Header({ agentName, sessionId, model, apiStyle, endpoint, permissionMode, thinkingLevel, status, pendingTools, }) {
+export const Header = React.memo(function Header({ agentName, sessionId, model, apiStyle, endpoint, permissionMode, thinkingLevel, status, pendingTools, termWidth: termWidthProp, }) {
     const color = statusColor(status);
-    const termWidth = process.stdout.columns || 80;
+    const termWidth = termWidthProp ?? (process.stdout.columns || 80);
     // Build config line with progressive truncation for narrow terminals
     const configParts = [model, apiStyle];
     if (termWidth >= 60 && permissionMode !== 'default')
@@ -59,5 +59,5 @@ export const Header = React.memo(function Header({ agentName, sessionId, model,
     const host = truncateStr(stripEndpoint(endpoint), Math.max(10, termWidth - 30));
     const toolsLine = formatPendingToolsLine(pendingTools, termWidth);
     const toolsActive = pendingTools.length > 0;
-    return (_jsxs(Frame, { borderColor: "gray", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, color: "cyanBright", children: ["\u25CF ", truncateStr(agentName, Math.max(4, termWidth - status.length - 8))] }), _jsxs(Text, { color: color, children: ["\u25CF ", status] })] }), _jsx(Text, { dimColor: true, wrap: "truncate", children: configParts.join(' · ') }), _jsxs(Text, { dimColor: true, wrap: "truncate", children: [host, "  session:", sessionId.slice(0, 8)] }), _jsx(Text, { color: toolsActive ? 'yellow' : undefined, dimColor: !toolsActive, wrap: "truncate", children: toolsLine })] }));
+    return (_jsxs(Frame, { borderColor: "gray", termWidth: termWidth, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, color: "cyanBright", children: ["\u25CF ", truncateStr(agentName, Math.max(4, termWidth - status.length - 8))] }), _jsxs(Text, { color: color, children: ["\u25CF ", status] })] }), _jsx(Text, { dimColor: true, wrap: "truncate", children: configParts.join(' · ') }), _jsxs(Text, { dimColor: true, wrap: "truncate", children: [host, " session:", sessionId.slice(0, 8)] }), _jsx(Text, { color: toolsActive ? 'yellow' : undefined, dimColor: !toolsActive, wrap: "truncate", children: toolsLine })] }));
 });

package/dist/components/log-row.js

@@ -17,12 +17,12 @@ function formatTime(timestamp) {
     const s = String(d.getSeconds()).padStart(2, '0');
     return `${h}:${m}:${s}`;
 }
-export const LogRow = React.memo(function LogRow({ entry }) {
+export const LogRow = React.memo(function LogRow({ entry, termWidth: termWidthProp, }) {
     const color = logColor(entry.kind);
     const symbol = SYMBOLS[entry.kind] ?? '·';
     const time = formatTime(entry.timestamp);
     const bodyLines = (entry.body || '[no content]').split('\n');
-    const termWidth = process.stdout.columns || 80;
+    const termWidth = termWidthProp ?? (process.stdout.columns || 80);
     const showTime = termWidth >= 50;
     return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: color, bold: true, children: [symbol, " ", entry.title] }), showTime ? _jsx(Text, { dimColor: true, children: time }) : null] }), _jsx(Box, { paddingLeft: 2, flexDirection: "column", children: entry.kind === 'assistant' ? (_jsx(AssistantMessage, { content: entry.body || '[no content]' })) : (bodyLines.map((line, index) => (_jsx(Text, { wrap: "truncate", children: line || ' ' }, `${entry.id}-${index}`)))) })] }));
 });