opencode-agora 0.4.0 → 0.4.2

package/dist/cli/shell.js

@@ -1,11 +1,12 @@
 import { execSync, spawn } from 'node:child_process';
-import { existsSync, mkdtempSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdtempSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { join, resolve, sep } from 'node:path';
 import { COMMANDS } from './commands-meta.js';
 import { runInteractiveMenu } from './menu.js';
 import { runTui } from './tui.js';
-import { AGORA_VERSION, FREE_MODELS } from './app.js';
+import { AGORA_VERSION } from './app.js';
+import { FREE_MODELS } from './commands/chat.js';
 import { detectAgoraDataDir, loadAgoraState, resolveSavedItems } from '../state.js';
 import { appendTranscript, loadSessionMeta, readTranscript, recentBashContext, writeSessionMeta } from '../transcript.js';
 import { gradientText, renderBanner, supportsTrueColor } from '../ui.js';
@@ -15,6 +16,8 @@ import { completeShellLine, ghostFromHistory } from './completions.js';
 import { getMarketplaceItems } from '../marketplace.js';
 const SHELL_BUILTINS = new Set(['cd', 'export', 'alias', 'source', 'unset', 'umask', 'exec']);
 const MAX_BASH_BUFFER = 16 * 1024;
+const SHELL_HISTORY_FILE = 'shell-history.jsonl';
+const SHELL_HISTORY_MAX = 2000;
 /** Map slash aliases (with leading `/`) to TUI page ids. */
 const TUI_SLASH_ALIASES = {
     '/tui': 'default',
@@ -26,6 +29,34 @@ const TUI_SLASH_ALIASES = {
     '/news': 'news',
     '/settings': 'settings'
 };
+const LETTER_SHORTCUTS = {
+    '/a': { kind: 'meta', sub: 'again' },
+    '/b': { kind: 'bash', cmd: 'agora browse' },
+    '/c': { kind: 'tui', page: 'community' },
+    '/d': { kind: 'bash', cmd: 'agora config doctor' },
+    '/e': { kind: 'meta', sub: 'env' },
+    '/f': { kind: 'meta', sub: 'fg' },
+    '/g': { kind: 'bash', cmd: 'agora search' },
+    '/h': { kind: 'tui', page: 'home' },
+    '/i': { kind: 'bash', cmd: 'agora init' },
+    '/j': { kind: 'meta', sub: 'jobs' },
+    '/k': { kind: 'bash', cmd: 'agora search' },
+    '/l': { kind: 'meta', sub: 'last' },
+    '/m': { kind: 'tui', page: 'marketplace' },
+    '/n': { kind: 'tui', page: 'news' },
+    '/o': { kind: 'bash', cmd: 'agora browse' },
+    '/p': { kind: 'bash', cmd: 'agora preferences' },
+    '/q': { kind: 'meta', sub: 'quit' },
+    '/r': { kind: 'bash', cmd: 'agora reviews' },
+    '/s': { kind: 'tui', page: 'settings' },
+    '/t': { kind: 'meta', sub: 'terminal' },
+    '/u': { kind: 'bash', cmd: 'agora use' },
+    '/v': { kind: 'meta', sub: 'verbose' },
+    '/w': { kind: 'bash', cmd: 'agora watch' },
+    '/x': { kind: 'bash', cmd: 'agora export' },
+    '/y': { kind: 'bash', cmd: 'agora history' },
+    '/z': { kind: 'bash', cmd: 'agora config doctor --fix' }
+};
 const QUESTION_STARTERS = new Set([
     'what',
     'why',
@@ -58,12 +89,20 @@ const QUESTION_STARTERS = new Set([
     'hey',
     'thanks'
 ]);
+const ENV_VAR_RE = /^[A-Za-z_][A-Za-z0-9_]*=/;
+const BACKTICK_RE = /^`[^`]+`/;
 export function looksLikeQuestion(line) {
     const trimmed = line.trim();
     if (!trimmed)
         return false;
     if (trimmed.endsWith('?'))
         return true;
+    // Env-prefixed commands (FOO=bar cmd) are always bash, never questions
+    if (ENV_VAR_RE.test(trimmed))
+        return false;
+    // Backtick-prefixed commands are always bash
+    if (BACKTICK_RE.test(trimmed))
+        return false;
     const words = trimmed.split(/\s+/);
     const firstWord = words[0].toLowerCase();
     if (QUESTION_STARTERS.has(firstWord))
@@ -79,6 +118,8 @@ export function classifyInput(line, isExecutable) {
     const trimmed = line.trim();
     if (!trimmed)
         return { kind: 'noop' };
+    if (trimmed === '/abc')
+        return { kind: 'meta', sub: 'abc' };
     if (trimmed === '/help')
         return { kind: 'meta', sub: 'help' };
     if (trimmed === '/quit')
@@ -103,6 +144,14 @@ export function classifyInput(line, isExecutable) {
         return { kind: 'meta', sub: 'last' };
     if (trimmed === '/again')
         return { kind: 'meta', sub: 'again' };
+    if (trimmed === '/jobs')
+        return { kind: 'meta', sub: 'jobs' };
+    if (trimmed === '/fg' || trimmed.startsWith('/fg '))
+        return { kind: 'meta', sub: 'fg', args: trimmed.slice(4).trim() };
+    if (trimmed === '/bg' || trimmed.startsWith('/bg '))
+        return { kind: 'meta', sub: 'bg', args: trimmed.slice(4).trim() };
+    if (trimmed === '/env' || trimmed.startsWith('/env '))
+        return { kind: 'meta', sub: 'env', args: trimmed.slice(5).trim() };
     if (trimmed.startsWith('/? '))
         return { kind: 'meta', sub: 'dry-run', args: trimmed.slice(3).trim() };
     if (trimmed.startsWith('!'))
@@ -116,7 +165,18 @@ export function classifyInput(line, isExecutable) {
         const target = TUI_SLASH_ALIASES[trimmed];
         return target === 'default' ? { kind: 'tui' } : { kind: 'tui', page: target };
     }
-    // Slash-prefixed inputs that weren't an exact meta or TUI match are
+    // Single-letter shortcuts (exact match only, no args).
+    const letterDisp = LETTER_SHORTCUTS[trimmed];
+    if (letterDisp) {
+        if (letterDisp.kind === 'meta') {
+            return { kind: 'meta', sub: letterDisp.sub };
+        }
+        if (letterDisp.kind === 'tui') {
+            return { kind: 'tui', page: letterDisp.page };
+        }
+        return letterDisp;
+    }
+    // Slash-prefixed inputs that weren't an exact meta, TUI, or letter match are
     // forwarded to the `agora` CLI: `/agora help`, `/agora search foo`,
     // `/help tutorials`, `/foo` all become `agora <args>`. Never let
     // `/anything` fall through to bash — PATH-joining an absolute name like
@@ -244,6 +304,44 @@ function copyToClipboard(text) {
         // fall back silently
     }
 }
+// ── Shell history persistence ────────────────────────────────────────────────
+function getShellHistoryPath(dataDir) {
+    return join(dataDir, SHELL_HISTORY_FILE);
+}
+function loadShellHistory(dataDir) {
+    const path = getShellHistoryPath(dataDir);
+    if (!existsSync(path))
+        return [];
+    try {
+        const raw = readFileSync(path, 'utf8');
+        const entries = [];
+        for (const line of raw.split('\n').filter(Boolean).reverse()) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.line)
+                    entries.push(parsed.line);
+            }
+            catch {
+                continue;
+            }
+            if (entries.length >= SHELL_HISTORY_MAX)
+                break;
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+function appendShellHistory(dataDir, line) {
+    const path = getShellHistoryPath(dataDir);
+    try {
+        appendFileSync(path, JSON.stringify({ line, ts: new Date().toISOString() }) + '\n', 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+}
 // ── Main shell loop ─────────────────────────────────────────────────────────
 export async function runShell(io, style) {
     const env = io.env ?? {};
@@ -253,7 +351,7 @@ export async function runShell(io, style) {
         const motto = "Developers' CLI marketplace and community hub - type a command, bash or chat:";
         const mottoLine = gradientText(motto, { trueColor });
         const model = FREE_MODELS[0];
-        const infoLine = style.dim(`v${AGORA_VERSION} · ${model} · /terminal · /help · /menu · /search · /quit`);
+        const infoLine = style.dim(`v${AGORA_VERSION} · ${model} · /abc · /help · /menu · /search · /quit`);
         const slashLine = style.orange('/home · /marketplace · /community · /news · /settings');
         process.stdout.write(`\n${banner}\n\n${mottoLine}\n\n${infoLine}\n${slashLine}\n\n`);
     }
@@ -286,6 +384,9 @@ export async function runShell(io, style) {
     let verbosity = 'medium';
     let childActive = false;
     let totalCost = 0;
+    const trackedEnv = new Map();
+    let jobCounter = 0;
+    const jobs = new Map();
     // Lazy caches for completion ids
     let cachedMarketplaceIds = null;
     let cachedSavedIds = null;
@@ -312,6 +413,7 @@ export async function runShell(io, style) {
         '/comm',
         '/news',
         '/settings',
+        '/abc',
         '/help',
         '/menu',
         '/transcript',
@@ -323,6 +425,10 @@ export async function runShell(io, style) {
         '/exit',
         '/last',
         '/again',
+        '/env',
+        '/jobs',
+        '/fg',
+        '/bg',
         ...agoraSlashCommands
     ];
     // Deduplicate: /news, /home etc may appear in both lists
@@ -348,9 +454,10 @@ export async function runShell(io, style) {
         },
         cwd: currentCwd
     };
-    // In-memory history for prompter (not persisted — transcript covers that)
-    const history = [];
+    // Shell history — persisted to disk and loaded on startup
+    const history = loadShellHistory(dataDir);
     const tips = [
+        'type /abc for a quick letter-shortcut reference (/a /b /c ...)',
         'type /help to see all slash commands',
         'type /menu to browse the command catalog',
         'type ?<msg> to force AI chat',
@@ -358,20 +465,39 @@ export async function runShell(io, style) {
         'type /clear to reset and see the home banner',
         'type /transcript to see your last 20 commands',
         'type /last to re-run the last bash command',
+        'type /again to re-send the last chat message',
+        'type /? <agora_cmd> to dry-run an agora command',
         'type ?how do I use MCP? to ask about the marketplace',
         'type /verbose for detailed AI responses',
         'type /quiet for minimal AI responses',
+        'type /env to view tracked env vars, /env FOO=val to set one',
         'press Tab to auto-complete commands and paths',
         'press Ctrl-R to reverse-search your history',
         'press Ctrl-L to clear the screen',
         'press Esc to dismiss ghost suggestions',
         'run `agora search --table` for a table view',
         'run `agora search --sort stars` to sort by stars',
-        'run `agora search --sort name --order asc` for alphabetical'
+        'run `agora search --sort name --order asc` for alphabetical',
+        'run `agora completions bash | source /dev/stdin` for bash completions',
+        'run `agora completions zsh > /usr/local/share/zsh/site-functions/_agora` for zsh completions',
+        'run `agora completions fish > ~/.config/fish/completions/agora.fish` for fish completions',
+        'type /home to open the TUI Home page',
+        'type /marketplace to open the TUI Marketplace page',
+        'type /settings to open the TUI Settings page',
+        'run `agora save <id>` to bookmark a package',
+        'run `agora saved` to see your saved items',
+        'run `agora auth login --api-url <url>` to connect the community',
+        'run `agora config doctor` to check your OpenCode config',
+        'type VAR=val command to set env vars in bash',
+        'pipe output with | or redirect with > as normal in bash',
+        'append & to run a command in the background',
+        'type /jobs to see background jobs, /fg to bring one forward',
+        'type /bg to resume a stopped job in the background',
+        'run `agora shell` anywhere to re-enter this interactive mode'
     ];
     // Amber chevron when opencode unavailable, accent otherwise
-    const accentChevron = opencodeAvailable ? style.accent('›') : '\x1b[38;5;214m›\x1b[0m';
-    // B.3 — static portion of the prompt (no chevron); suffix added dynamically
+    const accentChevron = opencodeAvailable ? style.accent('›') : style.orange('›');
+    // Static portion of the prompt (no chevron); suffix added dynamically
     function buildPromptBase() {
         return style.accent('agora') + ' ' + style.dim(shortCwd(currentCwd)) + ' ';
     }
@@ -382,15 +508,18 @@ export async function runShell(io, style) {
     }
     function buildContextLine() {
         const model = FREE_MODELS[0];
-        const tip = tips[(meta?.turnCount ?? 0) % tips.length];
-        return style.dim(`model: ${model} · ${tip}`);
+        const turnCount = meta?.turnCount ?? 0;
+        const tip = tips[turnCount % tips.length];
+        const parts = [`model: ${model}`, `${turnCount} turns`];
+        if (totalCost > 0)
+            parts.push(`$${totalCost.toFixed(6)}`);
+        parts.push(tip);
+        return style.dim(parts.join(' · '));
     }
     const sigintHandler = () => {
+        // SIGINT while idle: prompter handles Ctrl-C bytes directly via raw mode
         if (childActive)
             return;
-        // Ctrl-C while idle: the prompter handles abort; SIGINT from outside is rare
-        process.stdout.write('\n');
-        process.exit(0);
     };
     process.on('SIGINT', sigintHandler);
     try {
@@ -417,9 +546,10 @@ export async function runShell(io, style) {
             const line = result.value;
             if (!line.trim())
                 continue;
-            // Add to history
+            // Add to history and persist
             if (history[history.length - 1] !== line) {
                 history.push(line);
+                appendShellHistory(dataDir, line);
             }
             const dispatch = classifyInput(line, isExecutable);
             if (dispatch.kind === 'noop')
@@ -432,6 +562,10 @@ export async function runShell(io, style) {
                     printHome();
                     continue;
                 }
+                if (dispatch.sub === 'abc') {
+                    printLetterHelp(style);
+                    continue;
+                }
                 if (dispatch.sub === 'help') {
                     printHelp(style);
                     continue;
@@ -503,6 +637,115 @@ export async function runShell(io, style) {
                     }
                     continue;
                 }
+                if (dispatch.sub === 'jobs') {
+                    if (jobs.size === 0) {
+                        process.stdout.write(style.dim('No background jobs. Append & to run a command in the background.') + '\n');
+                    }
+                    else {
+                        process.stdout.write(style.accent('Background jobs') + '\n');
+                        for (const [id, job] of jobs) {
+                            const status = job.status === 'running' ? style.dim('running') : style.dim('stopped');
+                            process.stdout.write(`  [${id}] ${status}  ${job.cmd}\n`);
+                        }
+                    }
+                    continue;
+                }
+                if (dispatch.sub === 'fg') {
+                    if (jobs.size === 0) {
+                        process.stdout.write(style.dim('No background jobs. Append & to run a command in the background.') + '\n');
+                        continue;
+                    }
+                    const arg = dispatch.args || '';
+                    if (arg && Number.isNaN(parseInt(arg, 10))) {
+                        process.stdout.write(style.dim(`Invalid job id: ${arg}`) + '\n');
+                        continue;
+                    }
+                    const targetId = arg ? parseInt(arg, 10) : Math.max(...Array.from(jobs.keys()));
+                    const job = jobs.get(targetId);
+                    if (!job) {
+                        process.stdout.write(style.dim(`Job ${targetId} not found.`) + '\n');
+                        continue;
+                    }
+                    try {
+                        process.kill(job.pid, 0);
+                        process.stdout.write(style.dim(`Foreground: ${job.cmd}`) + '\n');
+                        await new Promise((resolve) => {
+                            const check = setInterval(() => {
+                                try {
+                                    process.kill(job.pid, 0);
+                                }
+                                catch {
+                                    clearInterval(check);
+                                    jobs.delete(targetId);
+                                    resolve();
+                                }
+                            }, 200);
+                        });
+                    }
+                    catch {
+                        jobs.delete(targetId);
+                        process.stdout.write(style.dim(`Job ${targetId} has finished.`) + '\n');
+                    }
+                    continue;
+                }
+                if (dispatch.sub === 'bg') {
+                    if (jobs.size === 0) {
+                        process.stdout.write(style.dim('No background jobs. Append & to run a command in the background.') + '\n');
+                        continue;
+                    }
+                    const arg = dispatch.args || '';
+                    if (arg && Number.isNaN(parseInt(arg, 10))) {
+                        process.stdout.write(style.dim(`Invalid job id: ${arg}`) + '\n');
+                        continue;
+                    }
+                    const targetId = arg ? parseInt(arg, 10) : Math.max(...Array.from(jobs.keys()));
+                    const job = jobs.get(targetId);
+                    if (!job) {
+                        process.stdout.write(style.dim(`Job ${targetId} not found.`) + '\n');
+                        continue;
+                    }
+                    try {
+                        process.kill(job.pid, 0);
+                        job.status = 'running';
+                        process.stdout.write(style.dim(`[${targetId}] ${job.cmd} (background)`) + '\n');
+                    }
+                    catch {
+                        jobs.delete(targetId);
+                        process.stdout.write(style.dim(`Job ${targetId} has finished.`) + '\n');
+                    }
+                    continue;
+                }
+                if (dispatch.sub === 'env') {
+                    const arg = dispatch.args || '';
+                    if (!arg) {
+                        if (trackedEnv.size === 0) {
+                            process.stdout.write(style.dim('No tracked environment variables. Use /env VAR=value to set one.') + '\n');
+                        }
+                        else {
+                            process.stdout.write(style.accent('Tracked environment') + '\n');
+                            for (const [k, v] of [...trackedEnv.entries()].sort()) {
+                                process.stdout.write(`  ${k}=${v}\n`);
+                            }
+                        }
+                    }
+                    else if (arg.includes('=')) {
+                        const eqIdx = arg.indexOf('=');
+                        const key = arg.slice(0, eqIdx).trim();
+                        const val = arg.slice(eqIdx + 1).trim();
+                        trackedEnv.set(key, val);
+                        process.stdout.write(style.dim(`${key}=${val} (tracked)`) + '\n');
+                    }
+                    else {
+                        const val = trackedEnv.get(arg);
+                        if (val === undefined) {
+                            process.stdout.write(style.dim(`${arg} is not tracked.`) + '\n');
+                        }
+                        else {
+                            process.stdout.write(`${arg}=${val}\n`);
+                        }
+                    }
+                    continue;
+                }
                 continue;
             }
             if (dispatch.kind === 'tui') {
@@ -510,6 +753,46 @@ export async function runShell(io, style) {
                 continue;
             }
             if (dispatch.kind === 'bash') {
+                // Track env vars from export statements and VAR=val prefix
+                const bashLine = dispatch.cmd;
+                const exportMatch = bashLine.match(/^export\s+([A-Za-z_][A-Za-z0-9_]*)=(.+)$/);
+                if (exportMatch) {
+                    trackedEnv.set(exportMatch[1], exportMatch[2].trim());
+                }
+                else {
+                    const prefixMatch = bashLine.match(/^([A-Za-z_][A-Za-z0-9_]*)=(\S+)\s+/);
+                    if (prefixMatch) {
+                        trackedEnv.set(prefixMatch[1], prefixMatch[2].trim());
+                    }
+                }
+                // Background job handling
+                const bgMatch = bashLine.match(/^(.*?)\s*&$/);
+                if (bgMatch) {
+                    const actualCmd = bgMatch[1].trim();
+                    if (actualCmd) {
+                        jobCounter++;
+                        const jobId = jobCounter;
+                        const child = spawn(actualCmd, {
+                            shell: true,
+                            cwd: currentCwd,
+                            env: env,
+                            stdio: ['ignore', 'pipe', 'pipe']
+                        });
+                        jobs.set(jobId, { pid: child.pid ?? 0, cmd: actualCmd, status: 'running' });
+                        process.stdout.write(style.dim(`[${jobId}] ${actualCmd} (background, pid ${child.pid ?? '?'})`) + '\n');
+                        child.stdout?.on('data', (chunk) => {
+                            const text = chunk.toString();
+                            const lines = text.split('\n').filter(Boolean);
+                            for (const l of lines)
+                                process.stdout.write(style.dim(`[${jobId}] ${l.trimRight()} |> `));
+                        });
+                        child.on('close', (code) => {
+                            jobs.delete(jobId);
+                            process.stdout.write(style.dim(`[${jobId}] finished (exit ${code ?? 0})`) + '\n');
+                        });
+                        continue;
+                    }
+                }
                 await runBash(dispatch.cmd);
                 continue;
             }
@@ -615,7 +898,7 @@ export async function runShell(io, style) {
         childActive = false;
         if (!done)
             childExitCode = 1;
-        // B.4 — show non-zero exit code
+        // Show non-zero exit code
         if (childExitCode !== 0) {
             process.stdout.write(style.dim(`· exit ${childExitCode}`) + '\n');
         }
@@ -659,7 +942,7 @@ export async function runShell(io, style) {
         };
         process.on('SIGINT', abortChat);
         childActive = true;
-        // B.4 — accumulate last 4 KB of stderr for failure diagnosis
+        // Accumulate last 4 KB of stderr for failure diagnosis
         let errBuffer = '';
         let chatExitCode = 0;
         let spawnError = null;
@@ -692,7 +975,7 @@ export async function runShell(io, style) {
         childActive = false;
         renderer.finalize();
         totalCost += renderer.getTotalCost();
-        // B.4 — detect and report chat failures
+        // Detect and report chat failures
         const chatFailed = spawnError !== null || (chatExitCode !== 0 && !renderer.hasReceivedText());
         if (chatFailed) {
             let reason;
@@ -777,6 +1060,22 @@ export async function runShell(io, style) {
         // s or other: skip silently
     }
 }
+function printLetterHelp(style) {
+    const lines = [
+        style.accent('Agora Shell — letter shortcuts'),
+        '',
+        '  /a  again     /b  browse    /c  community  /d  doctor   /e  env',
+        '  /f  fg        /g  search    /h  home       /i  init     /j  jobs',
+        '  /k  search    /l  last      /m  marketplace /n  news     /o  browse',
+        '  /p  preferences /q  quit   /r  reviews   /s  settings /t  terminal',
+        '  /u  use       /v  verbose   /w  watch     /x  export   /y  history',
+        '  /z  doctor --fix',
+        '',
+        'Shortcuts are exact matches only (no arguments).',
+        'Type /help for full command reference, /abc to show this again.'
+    ];
+    process.stdout.write(lines.join('\n') + '\n\n');
+}
 function printHelp(style) {
     const lines = [
         style.accent('Agora Shell — help'),
@@ -796,6 +1095,10 @@ function printHelp(style) {
         '  /last         re-run most recent bash command',
         '  /again        re-send most recent chat message',
         '  /? <cmd>      dry-run an agora command (e.g. /? install mcp-github)',
+        '  /abc          show letter-shortcut reference (/a /b /c ...)',
+        '  /jobs         list background jobs',
+        '  /fg [N]       bring job N (or last) to foreground',
+        '  /bg [N]       resume job N (or last) in background',
         '',
         style.dim('Verbosity:'),
         '  /verbose  /medium  /quiet',