atom-lite 0.5.1 → 0.6.2

package/dist/cli/app.js

@@ -1,10 +1,12 @@
 import { loadConfig } from "../config/load.js";
+import { DEFAULT_SYSTEM_PROMPT } from "../agent/system-prompt.js";
 import { defaultAgentDir, userConfigDir } from "../config/paths.js";
 import { saveProviderSelection, saveTheme, } from "../config/write.js";
 import { resolveApiKey, saveApiKey } from "../config/credentials.js";
 import { join } from "node:path";
 import { writeFileSync, existsSync } from "node:fs";
-import { execSync } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
+import { defaultShell, terminateProcessTree } from "../security/process.js";
 import { openSearchablePicker } from "./picker.js";
 import { openCommandPalette } from "./palette.js";
 import { bareCommandName, createCommandRegistry } from "./commands.js";
@@ -13,7 +15,6 @@ import { SecretInput } from "./secret-input.js";
 import { StatusLine } from "./status-line.js";
 import { Activity } from "./activity.js";
 import { ToolBox } from "./tool-box.js";
-import { ApprovalPrompt } from "./approval-prompt.js";
 import { Banner } from "./banner.js";
 import { formatContextUsage, knownContextWindow, } from "../providers/context-window.js";
 import { StreamText } from "./stream-text.js";
@@ -27,7 +28,7 @@ import { ProjectTrustPrompt } from "./trust-prompt.js";
 import { formatSessionList, formatSessionSearch, searchSessions, sessionTitleFromEvents, } from "../sessions/search.js";
 import { providerSwitchNotice, sessionHistoryLines, sessionSelectionFromEvents, } from "../sessions/history.js";
 import { blockAtLine, createMouseCapture, handleMouseEvent, parseSgrMouse, shouldEnableMouse, } from "./mouse.js";
-import { readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool } from "../tools/index.js";
+import { readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool, grepTool, globTool } from "../tools/index.js";
 import { McpManager, formatMcpStatus, formatMcpDoctor, createMcpTools } from "../mcp/index.js";
 import { createProvider } from "../providers/factory.js";
 import { availableProviderNames, getPreset, listModelsForProvider, materializeProviderConfig, probeApiKey, providerLabel, PROVIDER_PRESETS, } from "../providers/catalog.js";
@@ -124,7 +125,7 @@ export async function run(args) {
         modelByProvider.set(provider.id, modelOverride);
     const useTools = !positional.includes("__notools__");
     const builtInTools = useTools
-        ? [readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool]
+        ? [readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool, grepTool, globTool]
         : [];
     const interactive = process.stdin.isTTY === true && !jsonMode;
     // one-shot task from positional or stdin
@@ -244,7 +245,7 @@ export async function run(args) {
         return results;
     };
     const contextManager = new ContextManager({
-        systemPrompt: "You are a coding assistant.",
+        systemPrompt: DEFAULT_SYSTEM_PROMPT,
         maxInputTokens: config.context.maxInputTokens ?? null,
         reserveOutputTokens: config.context.reserveOutputTokens,
         compactAtPercent: config.context.compactAtPercent,
@@ -256,7 +257,7 @@ export async function run(args) {
     });
     let sessionTrusted = false;
     const approvals = {
-        mode: config.runtime.approvalMode ?? "ask",
+        mode: "ask",
         // Installed below once the interactive UI helpers exist.
         handler: undefined,
         isTrusted: () => sessionTrusted,
@@ -271,6 +272,9 @@ export async function run(args) {
         workspace: process.cwd(),
         tools: allTools,
         approvals,
+        mode: config.runtime.mode,
+        maxTokensPerSession: config.runtime.maxTokensPerSession,
+        maxTokensPerTurn: config.runtime.maxTokensPerTurn,
         contextManager,
         extensionDispatch,
         bashConcurrency: config.runtime.bashConcurrency,
@@ -359,10 +363,12 @@ export async function run(args) {
     const header = new Text(theme.tokens.dim(headerLabel()), 1, 0);
     const statusBar = new StatusLine(theme);
     const activity = new Activity({ theme, onChange: () => updateStatus() });
+    let currentMode = config.runtime.mode;
     statusBar.setParts({
         left: `${provider.id}/${provider.model ?? "default"}`,
         tokens: "tokens: ?",
         effort: "effort: medium",
+        mode: currentMode,
         activity: activity.text(),
     });
     const selectListTheme = {
@@ -397,18 +403,59 @@ export async function run(args) {
             return;
         commandRegistry = createCommandRegistry({ skills: cachedSkillRegistry().list() });
         registrySkillSignature = sig;
-        input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd()));
+        input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd(), fdPath));
     }
-    input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd()));
+    const fdPath = (() => {
+        for (const bin of ["fd", "fdfind"]) {
+            try {
+                const found = execSync(`command -v ${bin}`, {
+                    encoding: "utf8",
+                    stdio: ["ignore", "pipe", "ignore"],
+                }).trim();
+                if (found)
+                    return found;
+            }
+            catch {
+                // ignore
+            }
+        }
+        return null;
+    })();
+    input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd(), fdPath));
+    // Skills should autocomplete (fill the input) rather than execute immediately
+    // when selected from the autocomplete list; Enter on a typed command still
+    // runs them. Convert a confirming Enter into a Tab completion for skills.
+    const originalHandleInput = input.handleInput.bind(input);
+    input.handleInput = (data) => {
+        try {
+            if ((data === "\r" || data === "\n") &&
+                input.autocompleteState &&
+                input.autocompleteList) {
+                const selected = input.autocompleteList.getSelectedItem?.();
+                const name = selected?.value ?? selected?.name ?? selected?.label;
+                const cmd = name ? commandRegistry.get(String(name).replace(/^\//, "")) : undefined;
+                if (cmd?.bareInvokable) {
+                    originalHandleInput("\t");
+                    return;
+                }
+            }
+        }
+        catch {
+            // Fall through to default handling on any introspection failure.
+        }
+        originalHandleInput(data);
+    };
     const root = new VStack([]);
-    root.addChild(output, { grow: 1 });
-    root.addChild(new Spacer(1));
-    root.addChild(input);
-    root.addChild(statusBar);
+    // Keep fixed chrome (spacer, input, status, header, dropdown) from being
+    // collapsed when the transcript grows; only the output region may shrink.
+    root.addChild(output, { grow: 1, shrink: 1, minSize: 0 });
+    root.addChild(new Spacer(1), { grow: 0, shrink: 0, minSize: 1 });
+    root.addChild(input, { grow: 0, shrink: 0 });
+    root.addChild(statusBar, { grow: 0, shrink: 0 });
     // folder:branch info below the status line, dimmed
-    root.addChild(header);
+    root.addChild(header, { grow: 0, shrink: 0 });
     const dropdownContainer = new Container();
-    root.addChild(dropdownContainer);
+    root.addChild(dropdownContainer, { grow: 0, shrink: 0 });
     tui.setLayoutRoot(root);
     tui.setFocus(input);
     if (!noColor) {
@@ -536,6 +583,7 @@ export async function run(args) {
         streamText.finalize();
     }
     let activeTurnController = null;
+    let shellMode = false;
     const messageQueue = [];
     const steeringQueue = [];
     runtime.setSteeringQueue(steeringQueue);
@@ -549,7 +597,11 @@ export async function run(args) {
                 await mcpManager.syncTools();
                 runtime.setTools([...builtInTools, ...extensionTools, ...createMcpTools(mcpManager)]);
             }
-            await runtime.runAgentTurn(prompt, session, controller.signal);
+            const turnResult = await runtime.runAgentTurn(prompt, session, controller.signal);
+            if (turnResult === "TOKEN_BUDGET_REACHED") {
+                appendLine("token budget reached; stopping", theme.tokens.warning);
+                tui.requestRender();
+            }
         }
         catch (err) {
             if (err instanceof Error && err.message === "USER_CANCELLED") {
@@ -569,12 +621,94 @@ export async function run(args) {
             }
         }
     }
+    /** Run a shell command directly (shell mode / `!` prefix). */
+    async function runShellCommand(command) {
+        const shell = defaultShell();
+        const flag = process.platform === "win32" ? "/c" : "-c";
+        const start = Date.now();
+        const cap = 30000;
+        let stdout = "";
+        let stderr = "";
+        let truncated = false;
+        const append = (target, chunk) => {
+            const s = chunk.toString("utf8");
+            let accepted = s;
+            if (target === "out") {
+                if (stdout.length + s.length > cap) {
+                    truncated = true;
+                    accepted = s.slice(0, Math.max(0, cap - stdout.length));
+                    stdout += accepted;
+                }
+                else {
+                    stdout += s;
+                }
+            }
+            else {
+                if (stderr.length + s.length > cap) {
+                    truncated = true;
+                    accepted = s.slice(0, Math.max(0, cap - stderr.length));
+                    stderr += accepted;
+                }
+                else {
+                    stderr += s;
+                }
+            }
+            if (accepted) {
+                tui.requestRender();
+            }
+        };
+        try {
+            const child = spawn(shell, [flag, command], {
+                cwd: process.cwd(),
+                env: process.env,
+                detached: process.platform !== "win32",
+            });
+            child.stdout?.on("data", (c) => append("out", c));
+            child.stderr?.on("data", (c) => append("err", c));
+            const exit = await new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    terminateProcessTree(child, "SIGTERM");
+                    setTimeout(() => terminateProcessTree(child, "SIGKILL"), 1000).unref();
+                    resolve({ code: null, signal: "SIGTERM" });
+                }, 120000);
+                timer.unref();
+                child.on("exit", (code, signal) => {
+                    clearTimeout(timer);
+                    resolve({ code, signal });
+                });
+                child.on("error", (err) => {
+                    clearTimeout(timer);
+                    resolve({ code: null, signal: null });
+                    stderr = `COMMAND_FAILED: ${err instanceof Error ? err.message : String(err)}`;
+                });
+            });
+            const parts = [];
+            parts.push(`exit_code: ${exit.code ?? "null"}`);
+            if (exit.signal)
+                parts.push(`signal: ${exit.signal}`);
+            if (truncated)
+                parts.push("OUTPUT_TRUNCATED");
+            parts.push(`duration_ms: ${Date.now() - start}`);
+            if (stdout)
+                parts.push(`stdout:\n${stdout}`);
+            if (stderr)
+                parts.push(`stderr:\n${stderr}`);
+            const content = parts.join("\n");
+            appendLine(content, exit.code === 0 && !exit.signal && !stderr
+                ? theme.tokens.success
+                : theme.tokens.error);
+        }
+        catch (err) {
+            appendLine(`shell error: ${err instanceof Error ? err.message : String(err)}`, theme.tokens.error);
+        }
+    }
     function updateStatus() {
         const usage = runtime.getContextUsage();
         statusBar.setParts({
             left: `${provider.id}/${currentModelLabel()}`,
             tokens: `tokens: ${formatContextUsage(usage.used, usage.window)}`,
             effort: `effort: ${effortLevel}`,
+            mode: currentMode,
             activity: activity.text(),
         });
         tui.requestRender();
@@ -1085,13 +1219,15 @@ export async function run(args) {
             appendLine(`skill not found: ${name}`);
             return false;
         }
+        if (extra) {
+            appendLine(`> ${extra}`, theme.tokens.user);
+        }
         session.appendMessage({ role: "system", content });
         if (typeof session.appendEvent === "function") {
             session.appendEvent({ type: "skill_loaded", name });
         }
-        appendLine(`Loaded skill: ${name}`);
+        appendLine(`Loaded skill: ${name}`, theme.tokens.dim);
         if (extra) {
-            appendLine(`> ${extra}`);
             await runTurn(extra);
         }
         return true;
@@ -1359,6 +1495,7 @@ export async function run(args) {
         for (const box of toolBoxes) {
             box.setExpanded(expandTools);
         }
+        transcript.invalidate();
         tui.requestRender();
     }
     async function reloadExtensions() {
@@ -1482,6 +1619,7 @@ export async function run(args) {
         if (!(child instanceof ToolBox))
             return false;
         child.toggleExpanded();
+        transcript.invalidate();
         return true;
     }
     tui.addInputListener((data) => {
@@ -1516,11 +1654,28 @@ export async function run(args) {
             toggleTools();
             return { consume: true };
         }
-        // Escape cancels the active turn.
-        if (matchesKey(data, Key.escape) && !uiModalOpen && activeTurnController) {
-            activeTurnController.abort();
+        // Tab toggles plan/yolo mode.
+        if (matchesKey(data, Key.tab) && !uiModalOpen) {
+            currentMode = currentMode === "plan" ? "yolo" : "plan";
+            runtime.setMode(currentMode);
+            updateStatus();
+            appendLine(`mode: ${currentMode}`, theme.tokens.dim);
+            tui.requestRender();
             return { consume: true };
         }
+        // Escape cancels the active turn, or exits shell mode.
+        if (matchesKey(data, Key.escape) && !uiModalOpen) {
+            if (activeTurnController) {
+                activeTurnController.abort();
+                return { consume: true };
+            }
+            if (shellMode) {
+                shellMode = false;
+                appendLine("shell mode: off", theme.tokens.dim);
+                tui.requestRender();
+                return { consume: true };
+            }
+        }
         return undefined;
     });
     runtime["onEvent"] = (e) => {
@@ -1560,6 +1715,10 @@ export async function run(args) {
         else if (e.type === "context_usage") {
             updateStatus();
         }
+        else if (e.type === "budget_warning") {
+            appendLine(`budget warning (${e.scope}): ${e.used}/${e.limit} tokens`, theme.tokens.warning);
+            tui.requestRender();
+        }
         else if (e.type === "model_switched") {
             appendLine(`switched model to ${e.provider}/${e.model}`);
             if (typeof session.appendEvent === "function") {
@@ -1581,6 +1740,7 @@ export async function run(args) {
             if (box) {
                 activity.setPhase("working", e.name);
                 box.appendLive(e.text);
+                transcript.invalidate();
                 tui.requestRender();
             }
         }
@@ -1806,6 +1966,27 @@ export async function run(args) {
             tui.requestRender();
             return;
         }
+        // Shell mode: every line is a shell command. `!` alone (or as first char)
+        // enters shell mode; Escape exits it.
+        if (shellMode) {
+            const cmd = trimmed.startsWith("!") ? trimmed.slice(1).trim() : trimmed;
+            appendLine(`$ ${cmd}`, theme.tokens.user);
+            await runShellCommand(cmd);
+            tui.requestRender();
+            return;
+        }
+        // `!` as first character enters shell mode.
+        if (trimmed === "!" || trimmed.startsWith("! ")) {
+            shellMode = true;
+            const rest = trimmed.slice(1).trim();
+            appendLine("shell mode: on (Escape to exit)", theme.tokens.dim);
+            if (rest) {
+                appendLine(`$ ${rest}`, theme.tokens.user);
+                await runShellCommand(rest);
+            }
+            tui.requestRender();
+            return;
+        }
         refreshCommandRegistry();
         if (trimmed === "/steer" || trimmed.startsWith("/steer ")) {
             const text = trimmed.slice("/steer".length).trim();
@@ -1849,27 +2030,8 @@ export async function run(args) {
         appendLine(`> ${trimmed}`, theme.tokens.user);
         await runTurn(trimmed);
     };
-    approvals.handler = interactive
-        ? (req) => new Promise((resolve) => {
-            uiModalOpen = true;
-            closeOverlay();
-            dropdownContainer.clear();
-            activity.setPhase("waiting");
-            const prompt = new ApprovalPrompt(req, (decision) => {
-                uiModalOpen = false;
-                dropdownContainer.clear();
-                tui.setFocus(input);
-                activity.setPhase("working");
-                if (decision === "trust-session") {
-                    appendLine("trusted this session: shell commands will run without approval");
-                }
-                resolve(decision);
-            });
-            dropdownContainer.addChild(prompt);
-            tui.setFocus(prompt);
-            tui.requestRender();
-        })
-        : undefined;
+    // Approval prompts are superseded by plan/yolo modes.
+    approvals.handler = undefined;
     process.on("SIGTERM", () => {
         void mcpManager.close().finally(() => {
             tui.stop();