@devang0907/agent-dev 0.1.3 → 0.1.4

package/README.md

@@ -1,6 +1,6 @@
 # agent-dev
 
-A minimal pi-like terminal coding agent with an Ink UI. Chat with an AI that can read, write, edit files, and run bash commands.
+A minimal pi-like terminal coding agent with an Ink UI. Chat with an AI that can read, write, edit files, search the web, and run shell commands (with your approval).
 
 ## Quick start
 
@@ -51,7 +51,17 @@ Config and sessions are stored in `~/.agent-dev/`.
 
 ## Tools
 
-The agent has four built-in tools: `read`, `write`, `edit`, `bash`. File operations are restricted to the current working directory.
+The agent has five built-in tools:
+
+| Tool | Description |
+|------|-------------|
+| `read` | Read a file in the project directory |
+| `write` | Create or overwrite a file |
+| `edit` | Replace text in a file |
+| `web_search` | Search the internet (DuckDuckGo, no extra API key) |
+| `bash` | Run a shell command — **requires your approval** before execution |
+
+File operations are restricted to the current working directory. When the agent proposes a shell command, the UI prompts you to approve (`y`) or deny (`n` / Esc).
 
 ## License
 

package/dist/agent/loop.d.ts

@@ -1,5 +1,11 @@
 import type { ChatMessage, Model, ToolCall } from "../providers/types.js";
 import type { Settings } from "../config/settings.js";
+export interface PermissionRequest {
+    toolCallId: string;
+    name: string;
+    args: Record<string, unknown>;
+    command: string;
+}
 export type AgentEvent = {
     type: "message_start";
     role: "assistant";
@@ -28,5 +34,6 @@ export interface AgentLoopOptions {
     systemPrompt?: string;
     signal?: AbortSignal;
     onEvent: (event: AgentEvent) => void;
+    onPermissionRequest?: (request: PermissionRequest) => Promise<boolean>;
 }
 export declare function runAgentLoop(options: AgentLoopOptions): Promise<ChatMessage[]>;

package/dist/agent/loop.js

@@ -1,12 +1,24 @@
-import { normalizeToolCalls } from "../providers/openai-compat.js";
+import { normalizeToolCalls, parseMalformedToolCalls, extractFailedGeneration, } from "../providers/openai-compat.js";
 import { streamChat } from "../providers/registry.js";
-import { getToolDefinitions, executeTool } from "./tools/index.js";
+import { getToolDefinitions, executeTool, PERMISSION_REQUIRED_TOOLS } from "./tools/index.js";
+import { getPlatformContext } from "./platform.js";
 const MAX_TOOL_ROUNDS = 6;
 const MAX_SAME_TOOL_CALLS = 2;
-const DEFAULT_SYSTEM_PROMPT = `You are a helpful coding assistant with access to tools: read, write, edit, and bash.
+const DEFAULT_SYSTEM_PROMPT = `You are a helpful coding assistant with access to tools: read, write, edit, bash, and web_search.
 When the user asks you to create or modify files, call write or edit once with the full file content, then reply briefly to confirm.
+Use web_search when you need current information, documentation, or facts from the internet.
+Shell commands via bash require user approval before they run — propose the exact command you need.
+Never run long-lived dev servers (npm run dev, npm start) — they time out. Use npm run build to verify, then tell the user how to start the dev server locally.
 Do NOT call the same tool repeatedly with the same arguments. One successful write is enough.
-Working directory: ${process.cwd()}`;
+When calling tools, use the function-calling API with valid JSON arguments only (e.g. web_search: {"query": "search terms"}).
+
+${getPlatformContext()}`;
+function systemPromptForModel(model, base = DEFAULT_SYSTEM_PROMPT) {
+    if (model.provider === "groq") {
+        return `${base}\nFor Groq: never output <function=...> text — use structured tool calls with JSON arguments.`;
+    }
+    return base;
+}
 function isToolUseFailedError(message) {
     return /Failed to call a function|tool_use_failed|failed_generation/i.test(message);
 }
@@ -26,6 +38,74 @@ function dedupeToolCalls(toolCalls) {
         return true;
     });
 }
+function resolveToolCalls(content, toolCalls, error) {
+    const normalized = dedupeToolCalls(normalizeToolCalls(toolCalls.filter((tc) => tc.name)));
+    if (normalized.length > 0)
+        return normalized;
+    const fromContent = dedupeToolCalls(normalizeToolCalls(parseMalformedToolCalls(content)));
+    if (fromContent.length > 0)
+        return fromContent;
+    if (error) {
+        const failed = extractFailedGeneration(error);
+        if (failed) {
+            return dedupeToolCalls(normalizeToolCalls(parseMalformedToolCalls(failed)));
+        }
+    }
+    return [];
+}
+async function runToolBatch(uniqueCalls, context, workdir, callCounts, onEvent, onPermissionRequest) {
+    let stopAfterBatch = false;
+    for (const tc of uniqueCalls) {
+        onEvent({ type: "tool_call", toolCall: tc });
+        let args = {};
+        try {
+            args = JSON.parse(tc.arguments || "{}");
+        }
+        catch {
+            args = {};
+        }
+        const sig = toolSignature(tc.name, args);
+        const prev = callCounts.get(sig) ?? 0;
+        callCounts.set(sig, prev + 1);
+        if (prev >= MAX_SAME_TOOL_CALLS) {
+            const skip = "Skipped — already executed this action.";
+            onEvent({ type: "tool_result", toolCallId: tc.id, name: tc.name, result: skip });
+            context.push({ role: "tool", content: skip, toolCallId: tc.id, name: tc.name });
+            stopAfterBatch = true;
+            continue;
+        }
+        let result;
+        const needsPermission = PERMISSION_REQUIRED_TOOLS.has(tc.name);
+        if (needsPermission && onPermissionRequest) {
+            const approved = await onPermissionRequest({
+                toolCallId: tc.id,
+                name: tc.name,
+                args,
+                command: String(args.command ?? ""),
+            });
+            result = approved
+                ? await executeTool(tc.name, args, workdir)
+                : "Command execution denied by user.";
+        }
+        else if (needsPermission) {
+            result = "Command execution denied — permission handler not available.";
+        }
+        else {
+            result = await executeTool(tc.name, args, workdir);
+        }
+        onEvent({ type: "tool_result", toolCallId: tc.id, name: tc.name, result });
+        context.push({
+            role: "tool",
+            content: result,
+            toolCallId: tc.id,
+            name: tc.name,
+        });
+        if (!result.startsWith("Error:") && (tc.name === "write" || tc.name === "edit")) {
+            stopAfterBatch = true;
+        }
+    }
+    return stopAfterBatch;
+}
 async function collectStream(model, messages, settings, systemPrompt, signal, onEvent) {
     const tools = getToolDefinitions();
     let content = "";
@@ -55,7 +135,7 @@ async function collectStream(model, messages, settings, systemPrompt, signal, on
                 tc.arguments += event.argumentsDelta;
         }
         else if (event.type === "error") {
-            return { content, toolCalls: [], error: event.message };
+            return { content, toolCalls: Array.from(toolCallMap.values()), error: event.message };
         }
     }
     const toolCalls = normalizeToolCalls(Array.from(toolCallMap.values()).filter((tc) => tc.name));
@@ -70,9 +150,10 @@ function finishGracefully(context, content, onEvent) {
     onEvent({ type: "turn_end" });
 }
 export async function runAgentLoop(options) {
-    const { model, messages, settings, workdir, systemPrompt = DEFAULT_SYSTEM_PROMPT, signal, onEvent, } = options;
+    const { model, messages, settings, workdir, systemPrompt = DEFAULT_SYSTEM_PROMPT, signal, onEvent, onPermissionRequest, } = options;
     const context = [...messages];
     const callCounts = new Map();
+    const effectivePrompt = systemPromptForModel(model, systemPrompt);
     let toolRound = 0;
     while (true) {
         if (signal?.aborted)
@@ -83,8 +164,9 @@ export async function runAgentLoop(options) {
             break;
         }
         onEvent({ type: "message_start", role: "assistant" });
-        const { content, toolCalls, error } = await collectStream(model, context, settings, systemPrompt, signal, onEvent);
-        if (error) {
+        const { content, toolCalls, error } = await collectStream(model, context, settings, effectivePrompt, signal, onEvent);
+        const uniqueCalls = resolveToolCalls(content, toolCalls, error);
+        if (error && uniqueCalls.length === 0) {
             if (isToolUseFailedError(error) && hadSuccessfulToolResults(context)) {
                 finishGracefully(context, content, onEvent);
                 break;
@@ -92,49 +174,22 @@ export async function runAgentLoop(options) {
             onEvent({ type: "error", message: error });
             break;
         }
-        const uniqueCalls = dedupeToolCalls(toolCalls);
         const assistantMsg = {
             role: "assistant",
-            content,
+            content: error ? "" : content,
             toolCalls: uniqueCalls.length > 0 ? uniqueCalls : undefined,
         };
         context.push(assistantMsg);
         if (uniqueCalls.length === 0) {
-            onEvent({ type: "turn_end" });
-            break;
-        }
-        let stopAfterBatch = false;
-        for (const tc of uniqueCalls) {
-            onEvent({ type: "tool_call", toolCall: tc });
-            let args = {};
-            try {
-                args = JSON.parse(tc.arguments || "{}");
+            if (error) {
+                onEvent({ type: "error", message: error });
             }
-            catch {
-                args = {};
-            }
-            const sig = toolSignature(tc.name, args);
-            const prev = callCounts.get(sig) ?? 0;
-            callCounts.set(sig, prev + 1);
-            if (prev >= MAX_SAME_TOOL_CALLS) {
-                const skip = "Skipped — already executed this action.";
-                onEvent({ type: "tool_result", toolCallId: tc.id, name: tc.name, result: skip });
-                context.push({ role: "tool", content: skip, toolCallId: tc.id, name: tc.name });
-                stopAfterBatch = true;
-                continue;
-            }
-            const result = await executeTool(tc.name, args, workdir);
-            onEvent({ type: "tool_result", toolCallId: tc.id, name: tc.name, result });
-            context.push({
-                role: "tool",
-                content: result,
-                toolCallId: tc.id,
-                name: tc.name,
-            });
-            if (!result.startsWith("Error:") && (tc.name === "write" || tc.name === "edit")) {
-                stopAfterBatch = true;
+            else {
+                onEvent({ type: "turn_end" });
             }
+            break;
         }
+        const stopAfterBatch = await runToolBatch(uniqueCalls, context, workdir, callCounts, onEvent, onPermissionRequest);
         if (stopAfterBatch) {
             finishGracefully(context, content, onEvent);
             break;

package/dist/agent/platform.d.ts

@@ -0,0 +1,10 @@
+export interface ShellConfig {
+    executable: string;
+    args: string[];
+    name: string;
+    supportsAndAnd: boolean;
+}
+export declare function getShellConfig(): ShellConfig;
+/** Adapt common Unix-isms and command chaining for the host shell. */
+export declare function normalizeCommand(command: string, shell: ShellConfig): string;
+export declare function getPlatformContext(): string;

package/dist/agent/platform.js

@@ -0,0 +1,74 @@
+import { existsSync } from "node:fs";
+import { arch, platform, release } from "node:os";
+import { join } from "node:path";
+function findPwsh() {
+    const candidates = [
+        process.env.PWSH_PATH,
+        join(process.env.ProgramFiles ?? "C:\\Program Files", "PowerShell", "7", "pwsh.exe"),
+        join(process.env["ProgramFiles(x86)"] ?? "", "PowerShell", "7", "pwsh.exe"),
+    ].filter(Boolean);
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+export function getShellConfig() {
+    if (platform() === "win32") {
+        const pwsh = findPwsh();
+        if (pwsh) {
+            return {
+                executable: pwsh,
+                name: "PowerShell 7+ (pwsh)",
+                supportsAndAnd: true,
+                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command"],
+            };
+        }
+        return {
+            executable: "powershell.exe",
+            name: "Windows PowerShell",
+            supportsAndAnd: false,
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command"],
+        };
+    }
+    return {
+        executable: process.env.SHELL ?? "/bin/bash",
+        name: "bash",
+        supportsAndAnd: true,
+        args: ["-lc"],
+    };
+}
+/** Adapt common Unix-isms and command chaining for the host shell. */
+export function normalizeCommand(command, shell) {
+    let cmd = command.trim();
+    if (!cmd)
+        return cmd;
+    if (platform() === "win32") {
+        if (!shell.supportsAndAnd) {
+            cmd = cmd.replace(/\s&&\s/g, "; ");
+        }
+        cmd = cmd
+            .replace(/\bmkdir -p\s+/g, "New-Item -ItemType Directory -Force -Path ")
+            .replace(/\brm -rf\s+/g, "Remove-Item -Recurse -Force ")
+            .replace(/\brm -r\s+/g, "Remove-Item -Recurse -Force ")
+            .replace(/\btouch\s+/g, "New-Item -ItemType File -Force ");
+    }
+    return cmd;
+}
+export function getPlatformContext() {
+    const shell = getShellConfig();
+    const lines = [
+        `Platform: ${platform()} ${arch()} (${release()})`,
+        `Shell: ${shell.name}`,
+        `Working directory: ${process.cwd()}`,
+    ];
+    if (platform() === "win32") {
+        lines.push("This agent runs on Windows. Use PowerShell-compatible commands.", shell.supportsAndAnd
+            ? "You may chain commands with ; or &&."
+            : "Chain commands with ; (&& is NOT supported in Windows PowerShell 5).", "Examples: New-Item -ItemType Directory -Force todo-app; Set-Location todo-app", "For npx/npm scaffolding, always use non-interactive flags (--yes, -y, --defaults) and set CI=1.", "Do not use mkdir -p, rm -rf, or touch — use PowerShell equivalents or the write tool.", "Never run dev servers (npm run dev, npm start, next dev) via bash — they run forever and will time out.", "To verify a web app, use npm run build. Tell the user to run the dev server in their own terminal.", "Do not run npm audit fix unless the user explicitly asks.");
+    }
+    else {
+        lines.push("Use bash/sh syntax. Chain commands with && or ;.", "For npx/npm scaffolding, use non-interactive flags (--yes, -y) to avoid prompts.", "Never run dev servers (npm run dev, npm start) via bash — they run forever.", "To verify a web app, use npm run build. Tell the user to run the dev server separately.");
+    }
+    return lines.join("\n");
+}

package/dist/agent/session.d.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from "node:events";
 import type { ChatMessage, Model } from "../providers/types.js";
 import type { Settings } from "../config/settings.js";
-import { type AgentEvent } from "./loop.js";
+import { type AgentEvent, type PermissionRequest } from "./loop.js";
 import { SessionManager } from "../session/manager.js";
 export type SessionEvent = AgentEvent | {
     type: "user_message";
@@ -9,6 +9,9 @@ export type SessionEvent = AgentEvent | {
 } | {
     type: "model_changed";
     model: Model;
+} | {
+    type: "permission_request";
+    request: PermissionRequest;
 };
 export declare class AgentSession extends EventEmitter {
     private messages;
@@ -18,6 +21,7 @@ export declare class AgentSession extends EventEmitter {
     private sessionManager;
     private abortController?;
     private running;
+    private pendingPermission?;
     constructor(settings: Settings, sessionManager: SessionManager, workdir: string, initialModel?: Model);
     getModel(): Model;
     getSettings(): Settings;
@@ -26,6 +30,9 @@ export declare class AgentSession extends EventEmitter {
     setModel(model: Model): void;
     updateSettings(settings: Settings): void;
     abort(): void;
+    respondToPermission(approved: boolean): void;
+    private resolvePermission;
+    private requestCommandPermission;
     prompt(content: string): Promise<void>;
     newSession(): void;
     getAvailableModels(): Model[];

package/dist/agent/session.js

@@ -11,6 +11,7 @@ export class AgentSession extends EventEmitter {
     sessionManager;
     abortController;
     running = false;
+    pendingPermission;
     constructor(settings, sessionManager, workdir, initialModel) {
         super();
         this.settings = settings;
@@ -49,6 +50,23 @@ export class AgentSession extends EventEmitter {
     }
     abort() {
         this.abortController?.abort();
+        this.resolvePermission(false);
+    }
+    respondToPermission(approved) {
+        this.resolvePermission(approved);
+    }
+    resolvePermission(approved) {
+        const resolve = this.pendingPermission;
+        if (resolve) {
+            this.pendingPermission = undefined;
+            resolve(approved);
+        }
+    }
+    requestCommandPermission(request) {
+        return new Promise((resolve) => {
+            this.pendingPermission = resolve;
+            this.emit("event", { type: "permission_request", request });
+        });
     }
     async prompt(content) {
         if (this.running)
@@ -67,6 +85,7 @@ export class AgentSession extends EventEmitter {
                 workdir: this.workdir,
                 signal: this.abortController.signal,
                 onEvent: (event) => this.emit("event", event),
+                onPermissionRequest: (request) => this.requestCommandPermission(request),
             });
             for (const msg of newMessages) {
                 if (msg.role !== "user") {

package/dist/agent/tools/index.d.ts

@@ -4,5 +4,6 @@ export interface AgentTool {
     execute: (args: Record<string, unknown>, workdir: string) => Promise<string>;
 }
 export declare const BUILTIN_TOOLS: AgentTool[];
+export declare const PERMISSION_REQUIRED_TOOLS: Set<string>;
 export declare function getToolDefinitions(): ToolDefinition[];
 export declare function executeTool(name: string, args: Record<string, unknown>, workdir: string): Promise<string>;

package/dist/agent/tools/index.js

@@ -1,10 +1,13 @@
 import { readTool, writeTool, editTool, bashTool, executeRead, executeWrite, executeEdit, executeBash, } from "./read.js";
+import { webSearchTool, executeWebSearch } from "./search.js";
 export const BUILTIN_TOOLS = [
     { definition: readTool, execute: (args, wd) => executeRead(args, wd) },
     { definition: writeTool, execute: (args, wd) => executeWrite(args, wd) },
     { definition: editTool, execute: (args, wd) => executeEdit(args, wd) },
     { definition: bashTool, execute: (args, wd) => executeBash(args, wd) },
+    { definition: webSearchTool, execute: (args) => executeWebSearch(args) },
 ];
+export const PERMISSION_REQUIRED_TOOLS = new Set(["bash"]);
 export function getToolDefinitions() {
     return BUILTIN_TOOLS.map((t) => t.definition);
 }

package/dist/agent/tools/read.js

@@ -1,5 +1,8 @@
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { resolve, isAbsolute } from "node:path";
+import { platform as osPlatform } from "node:os";
+import { getShellConfig } from "../platform.js";
+import { executeShellCommand } from "./shell.js";
 const DEFAULT_WORKDIR = process.cwd();
 function resolvePath(path, workdir = DEFAULT_WORKDIR) {
     return isAbsolute(path) ? path : resolve(workdir, path);
@@ -81,7 +84,9 @@ export async function executeEdit(args, workdir = DEFAULT_WORKDIR) {
 }
 export const bashTool = {
     name: "bash",
-    description: "Run a shell command in the project directory",
+    description: osPlatform() === "win32"
+        ? "Run a PowerShell command in the project directory (Windows). Chain with ; not &&. Use non-interactive flags for npx/npm."
+        : "Run a bash shell command in the project directory",
     parameters: {
         type: "object",
         properties: {
@@ -92,21 +97,10 @@ export const bashTool = {
     },
 };
 export async function executeBash(args, workdir = DEFAULT_WORKDIR) {
-    const { exec } = await import("node:child_process");
-    const { promisify } = await import("node:util");
-    const execAsync = promisify(exec);
-    try {
-        const { stdout, stderr } = await execAsync(args.command, {
-            cwd: workdir,
-            timeout: 120000,
-            maxBuffer: 1024 * 1024,
-        });
-        const out = stdout + (stderr ? `\n${stderr}` : "");
-        return out.trim() || "(no output)";
-    }
-    catch (err) {
-        const e = err;
-        const out = (e.stdout ?? "") + (e.stderr ? `\n${e.stderr}` : "");
-        return out.trim() || (e.message ?? "Command failed");
+    const shell = getShellConfig();
+    const result = await executeShellCommand(args.command, workdir);
+    if (result.startsWith("Error:")) {
+        return `${result}\n(shell: ${shell.name})`;
     }
+    return result;
 }

package/dist/agent/tools/search.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDefinition } from "../../providers/types.js";
+export declare const webSearchTool: ToolDefinition;
+export declare function executeWebSearch(args: {
+    query: string;
+}): Promise<string>;

package/dist/agent/tools/search.js

@@ -0,0 +1,188 @@
+export const webSearchTool = {
+    name: "web_search",
+    description: "Search the internet for current information, documentation, or news",
+    parameters: {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Search query" },
+        },
+        required: ["query"],
+        additionalProperties: false,
+    },
+};
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+function stripHtml(text) {
+    return decodeHtmlEntities(text.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim());
+}
+function decodeHtmlEntities(text) {
+    return text
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/g, "'")
+        .replace(/&#39;/g, "'")
+        .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number(n)));
+}
+function extractAttr(tag, attr) {
+    const re = new RegExp(`${attr}=['"]([^'"]*)['"]`, "i");
+    return tag.match(re)?.[1] ?? null;
+}
+function decodeDdgUrl(href) {
+    try {
+        const match = href.match(/uddg=([^&]+)/);
+        if (match)
+            return decodeURIComponent(match[1]);
+        if (href.startsWith("//"))
+            return `https:${href}`;
+        return href;
+    }
+    catch {
+        return href;
+    }
+}
+function parseTagsByClass(html, className) {
+    const re = new RegExp(`<a\\b[^>]*class=['"]${className}['"][^>]*>[\\s\\S]*?<\\/a>`, "gi");
+    return html.match(re) ?? [];
+}
+function parseDdgLiteHtml(html) {
+    const linkTags = parseTagsByClass(html, "result-link");
+    const snippetRe = /<td[^>]*class=['"]result-snippet['"][^>]*>([\s\S]*?)<\/td>/gi;
+    const snippets = [];
+    let match;
+    while ((match = snippetRe.exec(html)) !== null) {
+        snippets.push(stripHtml(match[1]));
+    }
+    const results = [];
+    for (let i = 0; i < linkTags.length && results.length < 8; i++) {
+        const tag = linkTags[i];
+        const href = extractAttr(tag, "href");
+        const title = stripHtml(tag.replace(/^<a\b[^>]*>/i, "").replace(/<\/a>$/i, ""));
+        if (href && title) {
+            results.push({
+                title,
+                url: decodeDdgUrl(href),
+                snippet: snippets[i] ?? "",
+            });
+        }
+    }
+    return results;
+}
+function parseDdgHtmlResults(html) {
+    const linkTags = parseTagsByClass(html, "result__a");
+    const snippetTags = parseTagsByClass(html, "result__snippet");
+    const results = [];
+    for (let i = 0; i < linkTags.length && results.length < 8; i++) {
+        const tag = linkTags[i];
+        const href = extractAttr(tag, "href");
+        const title = stripHtml(tag.replace(/^<a\b[^>]*>/i, "").replace(/<\/a>$/i, ""));
+        const snippetTag = snippetTags[i];
+        const snippet = snippetTag
+            ? stripHtml(snippetTag.replace(/^<a\b[^>]*>/i, "").replace(/<\/a>$/i, ""))
+            : "";
+        if (href && title) {
+            results.push({ title, url: decodeDdgUrl(href), snippet });
+        }
+    }
+    return results;
+}
+async function fetchDdgLiteResults(query) {
+    const res = await fetch("https://lite.duckduckgo.com/lite/", {
+        method: "POST",
+        headers: {
+            "User-Agent": USER_AGENT,
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: new URLSearchParams({ q: query }),
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        throw new Error(`DuckDuckGo lite failed (${res.status})`);
+    return parseDdgLiteHtml(await res.text());
+}
+async function fetchDdgHtmlResults(query) {
+    const res = await fetch("https://html.duckduckgo.com/html/", {
+        method: "POST",
+        headers: {
+            "User-Agent": USER_AGENT,
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: new URLSearchParams({ q: query, b: "", kl: "" }),
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        throw new Error(`DuckDuckGo html failed (${res.status})`);
+    return parseDdgHtmlResults(await res.text());
+}
+async function fetchWebResults(query) {
+    const lite = await fetchDdgLiteResults(query);
+    if (lite.length > 0)
+        return lite;
+    return fetchDdgHtmlResults(query);
+}
+async function fetchDdgInstantAnswer(query) {
+    const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_redirect=1&no_html=1`;
+    const res = await fetch(url, {
+        headers: { "User-Agent": "agent-dev/1.0" },
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok)
+        return null;
+    const data = (await res.json());
+    const parts = [];
+    if (data.AbstractText) {
+        parts.push(data.Heading ? `${data.Heading}: ${data.AbstractText}` : data.AbstractText);
+        if (data.AbstractURL)
+            parts.push(`Source: ${data.AbstractURL}`);
+    }
+    for (const topic of data.RelatedTopics ?? []) {
+        if ("Text" in topic && topic.Text) {
+            parts.push(topic.Text);
+            if (topic.FirstURL)
+                parts.push(`  ${topic.FirstURL}`);
+        }
+        else if ("Topics" in topic && topic.Topics) {
+            for (const sub of topic.Topics) {
+                if (sub.Text)
+                    parts.push(sub.Text);
+            }
+        }
+        if (parts.length >= 6)
+            break;
+    }
+    return parts.length > 0 ? parts.join("\n") : null;
+}
+function formatResults(query, instant, web) {
+    const lines = [`Search results for: ${query}`, ""];
+    if (instant) {
+        lines.push("Instant answer:", instant, "");
+    }
+    if (web.length === 0) {
+        lines.push(instant ? "(No additional web results.)" : "No results found.");
+        return lines.join("\n");
+    }
+    lines.push("Web results:");
+    for (const [i, r] of web.entries()) {
+        lines.push(`${i + 1}. ${r.title}`);
+        lines.push(`   ${r.url}`);
+        if (r.snippet)
+            lines.push(`   ${r.snippet}`);
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+export async function executeWebSearch(args) {
+    const query = args.query?.trim();
+    if (!query)
+        return "Error: query is required";
+    try {
+        const [instant, web] = await Promise.all([
+            fetchDdgInstantAnswer(query).catch(() => null),
+            fetchWebResults(query),
+        ]);
+        return formatResults(query, instant, web);
+    }
+    catch (err) {
+        return `Error: search failed — ${err instanceof Error ? err.message : String(err)}`;
+    }
+}

package/dist/agent/tools/shell.d.ts

@@ -0,0 +1 @@
+export declare function executeShellCommand(command: string, workdir: string): Promise<string>;

package/dist/agent/tools/shell.js

@@ -0,0 +1,63 @@
+import { spawn } from "node:child_process";
+import { getShellConfig, normalizeCommand } from "../platform.js";
+const DEFAULT_TIMEOUT_MS = 120_000;
+const INSTALL_TIMEOUT_MS = 300_000;
+const DEV_SERVER_RE = /\b(npm run dev|npm start|yarn dev|pnpm dev|next dev|nuxt dev|vite(\s|$)|react-scripts start|node .*--watch)\b/i;
+const INSTALL_RE = /\b(npm install|npm ci|yarn install|pnpm install|npx create-|npm audit)\b/i;
+function getCommandTimeout(command) {
+    return INSTALL_RE.test(command) ? INSTALL_TIMEOUT_MS : DEFAULT_TIMEOUT_MS;
+}
+function isDevServerCommand(command) {
+    return DEV_SERVER_RE.test(command) || /\brun dev\b/i.test(command);
+}
+export async function executeShellCommand(command, workdir) {
+    const shell = getShellConfig();
+    const normalized = normalizeCommand(command, shell);
+    if (isDevServerCommand(normalized)) {
+        return [
+            "Error: dev servers run until stopped and cannot run inside the agent.",
+            `Suggested: open a separate terminal, cd to the project, then run: ${normalized.trim()}`,
+            "To verify the project here, use a one-shot command like: npm run build",
+        ].join("\n");
+    }
+    const timeoutMs = getCommandTimeout(normalized);
+    const args = [...shell.args, normalized];
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        const child = spawn(shell.executable, args, {
+            cwd: workdir,
+            env: {
+                ...process.env,
+                CI: "1",
+                FORCE_COLOR: "0",
+                npm_config_yes: "true",
+            },
+            windowsHide: true,
+        });
+        const timer = setTimeout(() => {
+            child.kill();
+            resolve(`Error: command timed out after ${timeoutMs / 1000}s\n${combineOutput(stdout, stderr)}\nTip: dev servers (npm run dev) cannot run here — use npm run build to verify, or run the dev server in your own terminal.`.trim());
+        }, timeoutMs);
+        child.stdout?.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve(`Error: ${err.message}`);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            const out = combineOutput(stdout, stderr);
+            if (code === 0)
+                return resolve(out.trim() || "(no output)");
+            resolve(out.trim() ? `${out.trim()}\n(exit ${code})` : `Error: command failed (exit ${code})`);
+        });
+    });
+}
+function combineOutput(stdout, stderr) {
+    return stdout + (stderr ? (stdout ? `\n${stderr}` : stderr) : "");
+}

package/dist/modes/print-mode.js

@@ -1,5 +1,19 @@
 import chalk from "chalk";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
 import { runAgentLoop } from "../agent/loop.js";
+async function promptCommandApproval(request) {
+    console.log(chalk.yellow(`\nCommand approval required:`));
+    console.log(chalk.white(`  ${request.command}`));
+    const rl = createInterface({ input, output });
+    try {
+        const answer = await rl.question(chalk.gray("Run? [y/N] "));
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
 export async function runPrintMode(session, prompt) {
     const model = session.getModel();
     console.log(chalk.gray(`Model: ${model.provider}/${model.id}`));
@@ -11,6 +25,7 @@ export async function runPrintMode(session, prompt) {
         messages: [...prior, userMsg],
         settings: session.getSettings(),
         workdir: process.cwd(),
+        onPermissionRequest: promptCommandApproval,
         onEvent: (event) => {
             if (event.type === "text_delta") {
                 process.stdout.write(event.delta);

package/dist/providers/openai-compat.d.ts

@@ -3,6 +3,8 @@ import type { ChatContext, StreamEvent, ToolCall } from "./types.js";
 export declare function sanitizeToolParameters(params: Record<string, unknown>): Record<string, unknown>;
 export declare function toOpenAITools(tools: ChatContext["tools"]): OpenAI.Chat.ChatCompletionTool[];
 export declare function normalizeToolCalls(toolCalls: ToolCall[]): ToolCall[];
+export declare function parseMalformedToolCalls(text: string): ToolCall[];
+export declare function extractFailedGeneration(errorMessage: string): string | null;
 export declare function toOpenAIMessages(ctx: ChatContext): OpenAI.Chat.ChatCompletionMessageParam[];
 export declare function processOpenAIStream(stream: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>): AsyncGenerator<StreamEvent>;
 export declare function formatApiError(err: unknown): string;

package/dist/providers/openai-compat.js

@@ -22,6 +22,101 @@ export function normalizeToolCalls(toolCalls) {
         arguments: tc.arguments?.trim() || "{}",
     }));
 }
+/** Recover tool calls Groq/Llama sometimes emit as malformed text instead of structured tool_calls. */
+function unescapeJsonString(value) {
+    return value
+        .replace(/\\n/g, "\n")
+        .replace(/\\t/g, "\t")
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, "\\");
+}
+function parseToolArguments(raw) {
+    const body = raw.replace(/^[\[\]\s]*/, "").trim();
+    if (!body.startsWith("{"))
+        return null;
+    try {
+        JSON.parse(body);
+        return body;
+    }
+    catch {
+        // Groq often truncates JSON — extract known fields.
+    }
+    const commandMatch = body.match(/"command"\s*:\s*"((?:\\.|[^"\\])*)"/);
+    if (commandMatch) {
+        return JSON.stringify({ command: unescapeJsonString(commandMatch[1]) });
+    }
+    const truncatedCommand = body.match(/"command"\s*:\s*"([\s\S]+)$/);
+    if (truncatedCommand) {
+        const command = unescapeJsonString(truncatedCommand[1].replace(/\\+$/, ""));
+        return JSON.stringify({ command });
+    }
+    const queryMatch = body.match(/"query"\s*:\s*"((?:\\.|[^"\\])*)"/);
+    if (queryMatch) {
+        return JSON.stringify({ query: unescapeJsonString(queryMatch[1]) });
+    }
+    const pathMatch = body.match(/"path"\s*:\s*"((?:\\.|[^"\\])*)"/);
+    if (pathMatch) {
+        return JSON.stringify({ path: unescapeJsonString(pathMatch[1]) });
+    }
+    return null;
+}
+function pushRecovered(results, name, args) {
+    results.push({
+        id: `recovered_${Date.now()}_${results.length}`,
+        name,
+        arguments: args,
+    });
+}
+export function parseMalformedToolCalls(text) {
+    const results = [];
+    if (!text)
+        return results;
+    const patterns = [
+        /<function=([a-zA-Z0-9_]+)\s*(?:\[\])?\s*(\{[\s\S]*?\})\s*<\/function>/gi,
+        /<function=([a-zA-Z0-9_]+)\s*>\s*(\{[\s\S]*?\})\s*<\/function>/gi,
+        /<tool_call>\s*([a-zA-Z0-9_]+)\s*(\{[\s\S]*?\})\s*<\/tool_call>/gi,
+    ];
+    for (const re of patterns) {
+        re.lastIndex = 0;
+        let match;
+        while ((match = re.exec(text)) !== null) {
+            const name = match[1].trim();
+            const args = parseToolArguments(match[2]);
+            if (name && args)
+                pushRecovered(results, name, args);
+        }
+        if (results.length > 0)
+            break;
+    }
+    if (results.length === 0) {
+        const looseRe = /<function=([a-zA-Z0-9_]+)([\s\S]*?)<\/function>/gi;
+        let match;
+        while ((match = looseRe.exec(text)) !== null) {
+            const name = match[1].trim();
+            const args = parseToolArguments(match[2]);
+            if (name && args)
+                pushRecovered(results, name, args);
+        }
+    }
+    if (results.length === 0) {
+        const truncatedRe = /<function=([a-zA-Z0-9_]+)\s*(?:\[\])?\s*(\{[\s\S]+)/gi;
+        let match;
+        while ((match = truncatedRe.exec(text)) !== null) {
+            const name = match[1].trim();
+            const args = parseToolArguments(match[2]);
+            if (name && args)
+                pushRecovered(results, name, args);
+        }
+    }
+    return results;
+}
+export function extractFailedGeneration(errorMessage) {
+    const marker = "Model output:";
+    const idx = errorMessage.indexOf(marker);
+    if (idx >= 0)
+        return errorMessage.slice(idx + marker.length).trim();
+    return null;
+}
 export function toOpenAIMessages(ctx) {
     const msgs = [];
     if (ctx.systemPrompt) {

package/dist/ui/App.d.ts

@@ -1,6 +1,7 @@
 import React from "react";
 import type { AgentSession } from "../agent/session.js";
 export interface DisplayMessage {
+    id: number;
     role: "user" | "assistant" | "tool";
     content: string;
     toolName?: string;

package/dist/ui/App.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect, useCallback, useRef } from "react";
-import { Box, useInput, useApp } from "ink";
+import { Box, useInput, useApp, useStdout } from "ink";
 import { ChatView } from "./ChatView.js";
 import { Editor } from "./Editor.js";
 import { Footer } from "./Footer.js";
@@ -9,8 +9,14 @@ import { ApiKeyPrompt } from "./ApiKeyPrompt.js";
 import { SettingsView } from "./SettingsView.js";
 import { hasProviderAuth, getDefaultModelForProvider } from "../providers/registry.js";
 import { findModel } from "../config/models.js";
+import { CommandApprovalPrompt } from "./CommandApprovalPrompt.js";
 import { StartupBanner } from "./StartupBanner.js";
 import { getTheme } from "./theme.js";
+import { scrollViewportToBottom } from "./scroll.js";
+let nextMessageId = 0;
+function toDisplayMessage(role, content, toolName) {
+    return { id: nextMessageId++, role, content, toolName };
+}
 function modelForProvider(provider, settings) {
     const current = findModel(settings.defaultProvider, settings.defaultModel);
     if (current?.provider === provider)
@@ -19,11 +25,7 @@ function modelForProvider(provider, settings) {
 }
 export function App({ session, workdir, onQuit }) {
     const { exit } = useApp();
-    const [displayMessages, setDisplayMessages] = useState(() => session.getMessages().map((m) => ({
-        role: m.role === "tool" ? "tool" : m.role === "user" ? "user" : "assistant",
-        content: m.content,
-        toolName: m.name,
-    })));
+    const [displayMessages, setDisplayMessages] = useState(() => session.getMessages().map((m) => toDisplayMessage(m.role === "tool" ? "tool" : m.role === "user" ? "user" : "assistant", m.content, m.name)));
     const [streamingText, setStreamingText] = useState("");
     const [overlay, setOverlay] = useState("none");
     const [modelFilter, setModelFilter] = useState();
@@ -32,9 +34,13 @@ export function App({ session, workdir, onQuit }) {
     const [settings, setSettings] = useState(session.getSettings());
     const [model, setModel] = useState(session.getModel());
     const [running, setRunning] = useState(false);
+    const [autoFollow, setAutoFollow] = useState(true);
+    const [pendingCommand, setPendingCommand] = useState(null);
     const streamingRef = useRef("");
+    const autoFollowRef = useRef(true);
     const startupChecked = useRef(false);
     const theme = getTheme();
+    const { stdout } = useStdout();
     const openApiKeyPrompt = useCallback((target, returnTo = "none") => {
         setPendingModel(target);
         setApiKeyReturnOverlay(returnTo);
@@ -65,18 +71,28 @@ export function App({ session, workdir, onQuit }) {
             openApiKeyPrompt(current, "none");
         }
     }, [session, settings, openApiKeyPrompt]);
+    useEffect(() => {
+        if (autoFollow && streamingText) {
+            scrollViewportToBottom(stdout);
+        }
+    }, [streamingText, autoFollow, stdout]);
     useEffect(() => {
         const handler = (event) => {
             switch (event.type) {
                 case "user_message":
-                    setDisplayMessages((prev) => [...prev, { role: "user", content: event.content }]);
+                    autoFollowRef.current = true;
+                    setAutoFollow(true);
+                    setDisplayMessages((prev) => [...prev, toDisplayMessage("user", event.content)]);
                     setRunning(true);
                     streamingRef.current = "";
                     setStreamingText("");
+                    scrollViewportToBottom(stdout);
                     break;
                 case "message_start":
                     streamingRef.current = "";
                     setStreamingText("");
+                    if (autoFollowRef.current)
+                        scrollViewportToBottom(stdout);
                     break;
                 case "text_delta":
                     streamingRef.current += event.delta;
@@ -85,7 +101,7 @@ export function App({ session, workdir, onQuit }) {
                 case "tool_call":
                     const partial = streamingRef.current;
                     if (partial) {
-                        setDisplayMessages((prev) => [...prev, { role: "assistant", content: partial }]);
+                        setDisplayMessages((prev) => [...prev, toDisplayMessage("assistant", partial)]);
                         streamingRef.current = "";
                         setStreamingText("");
                     }
@@ -93,13 +109,13 @@ export function App({ session, workdir, onQuit }) {
                 case "tool_result":
                     setDisplayMessages((prev) => [
                         ...prev,
-                        { role: "tool", content: event.result, toolName: event.name },
+                        toDisplayMessage("tool", event.result, event.name),
                     ]);
                     break;
                 case "turn_end":
                     const final = streamingRef.current;
                     if (final) {
-                        setDisplayMessages((prev) => [...prev, { role: "assistant", content: final }]);
+                        setDisplayMessages((prev) => [...prev, toDisplayMessage("assistant", final)]);
                     }
                     streamingRef.current = "";
                     setStreamingText("");
@@ -108,15 +124,20 @@ export function App({ session, workdir, onQuit }) {
                 case "error":
                     setDisplayMessages((prev) => [
                         ...prev,
-                        { role: "assistant", content: `Error: ${event.message}` },
+                        toDisplayMessage("assistant", `Error: ${event.message}`),
                     ]);
                     streamingRef.current = "";
                     setStreamingText("");
                     setRunning(false);
+                    setPendingCommand(null);
                     if (/Missing .*API_KEY/i.test(event.message)) {
                         openApiKeyPrompt(model, "none");
                     }
                     break;
+                case "permission_request":
+                    setPendingCommand(event.request);
+                    setOverlay("commandApproval");
+                    break;
                 case "model_changed":
                     setModel(event.model);
                     break;
@@ -126,12 +147,24 @@ export function App({ session, workdir, onQuit }) {
         return () => {
             session.off("event", handler);
         };
-    }, [session, model, openApiKeyPrompt]);
-    useInput((_, key) => {
+    }, [session, model, openApiKeyPrompt, stdout]);
+    autoFollowRef.current = autoFollow;
+    useInput((input, key) => {
         if (overlay !== "none")
             return;
         if (key.escape && running) {
             session.abort();
+            return;
+        }
+        if (key.pageUp || (key.upArrow && key.shift)) {
+            autoFollowRef.current = false;
+            setAutoFollow(false);
+            return;
+        }
+        if (input === "g" && key.ctrl) {
+            autoFollowRef.current = true;
+            setAutoFollow(true);
+            scrollViewportToBottom(stdout);
         }
     }, { isActive: overlay === "none" });
     const handleSubmit = useCallback(async (value) => {
@@ -144,6 +177,7 @@ export function App({ session, workdir, onQuit }) {
             session.newSession();
             setDisplayMessages([]);
             setStreamingText("");
+            setAutoFollow(true);
             return;
         }
         if (value === "/settings") {
@@ -165,7 +199,10 @@ export function App({ session, workdir, onQuit }) {
         await session.prompt(value);
     }, [session, running, onQuit, exit, model, settings, openApiKeyPrompt]);
     const hasChat = displayMessages.length > 0 || streamingText.length > 0;
-    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsx(Box, { paddingX: 2, marginBottom: 1, children: _jsx(StartupBanner, { theme: theme, compact: hasChat }) }), _jsx(ChatView, { messages: displayMessages, theme: theme, model: model, streamingText: streamingText, running: running }), _jsx(Footer, { workdir: workdir, model: model, theme: theme }), overlay === "none" && (_jsx(Editor, { theme: theme, model: model, disabled: running, running: running, onSubmit: handleSubmit })), overlay === "model" && (_jsx(ModelSelector, { theme: theme, settings: settings, filter: modelFilter, onSelect: (m) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { paddingX: 2, marginBottom: 1, flexShrink: 0, children: _jsx(StartupBanner, { theme: theme, compact: hasChat }) }), _jsx(ChatView, { messages: displayMessages, theme: theme, model: model, streamingText: streamingText, running: running, autoFollow: autoFollow }), _jsx(Footer, { workdir: workdir, model: model, theme: theme }), overlay === "none" && (_jsx(Box, { flexShrink: 0, children: _jsx(Editor, { theme: theme, model: model, disabled: running, running: running, onSubmit: handleSubmit, onPauseFollow: () => {
+                        autoFollowRef.current = false;
+                        setAutoFollow(false);
+                    } }) })), overlay === "model" && (_jsx(ModelSelector, { theme: theme, settings: settings, filter: modelFilter, onSelect: (m) => {
                     if (!hasProviderAuth(m.provider, settings)) {
                         openApiKeyPrompt(m, "model");
                         return;
@@ -186,5 +223,13 @@ export function App({ session, workdir, onQuit }) {
                     setSettings(s);
                 }, onSetApiKey: (provider) => {
                     openApiKeyPrompt(modelForProvider(provider, settings), "settings");
-                }, onClose: () => setOverlay("none") }))] }));
+                }, onClose: () => setOverlay("none") })), overlay === "commandApproval" && pendingCommand && (_jsx(CommandApprovalPrompt, { theme: theme, request: pendingCommand, onApprove: () => {
+                    session.respondToPermission(true);
+                    setPendingCommand(null);
+                    setOverlay("none");
+                }, onDeny: () => {
+                    session.respondToPermission(false);
+                    setPendingCommand(null);
+                    setOverlay("none");
+                } }))] }));
 }

package/dist/ui/ChatView.d.ts

@@ -8,6 +8,7 @@ interface ChatViewProps {
     model: Model;
     streamingText?: string;
     running?: boolean;
+    autoFollow?: boolean;
 }
-export declare function ChatView({ messages, theme, model, streamingText, running }: ChatViewProps): React.JSX.Element | null;
+export declare function ChatView({ messages, theme, model, streamingText, running, autoFollow, }: ChatViewProps): React.JSX.Element | null;
 export {};

package/dist/ui/ChatView.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from "react";
-import { Box, Text } from "ink";
+import { useEffect, useState } from "react";
+import { Box, Static, Text } from "ink";
 import { SPINNER_FRAMES, TOOL_ICONS } from "./theme.js";
 import { LeftBorder } from "./LeftBorder.js";
 import { Panel } from "./Panel.js";
@@ -8,7 +8,16 @@ import { modelRef } from "../config/models.js";
 function truncate(text, max) {
     return text.length > max ? text.slice(0, max) + "…" : text;
 }
-export function ChatView({ messages, theme, model, streamingText, running }) {
+function StaticMessage({ msg, theme, model, }) {
+    if (msg.role === "user") {
+        return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsx(LeftBorder, { theme: theme, borderColor: theme.primary, marginBottom: 0, children: _jsx(Text, { color: theme.text, children: msg.content }) }) }));
+    }
+    if (msg.role === "assistant") {
+        return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 1, children: [_jsx(Text, { color: theme.text, children: msg.content || "" }), _jsxs(Text, { color: theme.textMuted, children: [_jsx(Text, { color: theme.primary, children: "\u25A3 " }), modelRef(model)] })] }));
+    }
+    return (_jsx(Box, { paddingLeft: 1, marginBottom: 1, children: _jsxs(Text, { color: theme.text, children: [_jsx(Text, { color: theme.textMuted, children: TOOL_ICONS[msg.toolName ?? ""] ?? "⚙" }), " ", _jsx(Text, { bold: true, children: msg.toolName }), _jsxs(Text, { color: theme.textMuted, children: [" ", truncate(msg.content, 500)] })] }) }));
+}
+export function ChatView({ messages, theme, model, streamingText, running, autoFollow = true, }) {
     const [spinIdx, setSpinIdx] = useState(0);
     const hasContent = messages.length > 0 || (streamingText?.length ?? 0) > 0;
     useEffect(() => {
@@ -20,5 +29,6 @@ export function ChatView({ messages, theme, model, streamingText, running }) {
     if (!hasContent) {
         return null;
     }
-    return (_jsxs(Panel, { theme: theme, flexGrow: 1, borderColor: theme.border, children: [messages.map((msg, i) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [msg.role === "user" && (_jsx(LeftBorder, { theme: theme, borderColor: theme.primary, marginBottom: 0, children: _jsx(Text, { color: theme.text, children: msg.content }) })), msg.role === "assistant" && (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsx(Text, { color: theme.text, children: msg.content || "" }), _jsxs(Text, { color: theme.textMuted, children: [_jsx(Text, { color: theme.primary, children: "\u25A3 " }), modelRef(model)] })] })), msg.role === "tool" && (_jsx(Box, { paddingLeft: 1, children: _jsxs(Text, { color: theme.text, children: [_jsx(Text, { color: theme.textMuted, children: TOOL_ICONS[msg.toolName ?? ""] ?? "⚙" }), " ", _jsx(Text, { bold: true, children: msg.toolName }), _jsxs(Text, { color: theme.textMuted, children: [" ", truncate(msg.content, 200)] })] }) }))] }, i))), streamingText && (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsx(Text, { color: theme.text, children: streamingText }), _jsxs(Text, { color: theme.textMuted, children: [_jsxs(Text, { color: theme.primary, children: [SPINNER_FRAMES[spinIdx], " "] }), "responding\u2026"] })] })), running && !streamingText && messages.length > 0 && (_jsx(Box, { paddingLeft: 1, children: _jsxs(Text, { color: theme.textMuted, children: [_jsx(Text, { color: theme.primary, children: SPINNER_FRAMES[spinIdx] }), " working\u2026"] }) }))] }));
+    const showWorking = running && !streamingText && messages.length > 0;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Static, { items: messages, children: (msg) => (_jsx(StaticMessage, { msg: msg, theme: theme, model: model }, msg.id)) }), (streamingText || showWorking) && (_jsxs(Panel, { theme: theme, borderColor: theme.border, marginBottom: 1, children: [streamingText && (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsx(Text, { color: theme.text, children: streamingText }), _jsxs(Text, { color: theme.textMuted, children: [_jsxs(Text, { color: theme.primary, children: [SPINNER_FRAMES[spinIdx], " "] }), "responding\u2026", !autoFollow && (_jsx(Text, { color: theme.warning, children: " \u00B7 paused (Ctrl+G to follow)" }))] })] })), showWorking && (_jsx(Box, { paddingLeft: 1, children: _jsxs(Text, { color: theme.textMuted, children: [_jsx(Text, { color: theme.primary, children: SPINNER_FRAMES[spinIdx] }), " working\u2026"] }) }))] }))] }));
 }

package/dist/ui/CommandApprovalPrompt.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { ThemeColors } from "./theme.js";
+import type { PermissionRequest } from "../agent/loop.js";
+interface CommandApprovalPromptProps {
+    theme: ThemeColors;
+    request: PermissionRequest;
+    onApprove: () => void;
+    onDeny: () => void;
+}
+export declare function CommandApprovalPrompt({ theme, request, onApprove, onDeny, }: CommandApprovalPromptProps): React.JSX.Element;
+export {};

package/dist/ui/CommandApprovalPrompt.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { LeftBorder } from "./LeftBorder.js";
+export function CommandApprovalPrompt({ theme, request, onApprove, onDeny, }) {
+    useInput((input, key) => {
+        if (input === "y" || input === "Y") {
+            onApprove();
+            return;
+        }
+        if (input === "n" || input === "N" || key.escape) {
+            onDeny();
+        }
+    }, { isActive: true });
+    return (_jsx(Box, { flexDirection: "column", marginX: 2, marginTop: 1, marginBottom: 1, children: _jsxs(LeftBorder, { theme: theme, borderColor: theme.warning, children: [_jsx(Text, { color: theme.text, bold: true, children: "Run shell command?" }), _jsx(Text, { color: theme.textMuted, children: " y approve \u00B7 n or Esc deny" }), _jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: theme.warning, paddingX: 1, paddingY: 0, children: _jsx(Text, { color: theme.text, children: request.command }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.textMuted, children: "The agent wants to run this command in your project directory." }) })] }) }));
+}

package/dist/ui/Editor.d.ts

@@ -7,6 +7,7 @@ interface EditorProps {
     disabled?: boolean;
     running?: boolean;
     onSubmit: (value: string) => void;
+    onPauseFollow?: () => void;
 }
-export declare function Editor({ theme, model, disabled, running, onSubmit }: EditorProps): React.JSX.Element;
+export declare function Editor({ theme, model, disabled, running, onSubmit, onPauseFollow }: EditorProps): React.JSX.Element;
 export {};

package/dist/ui/Editor.js

@@ -10,7 +10,7 @@ function BlinkingCursor({ theme, visible }) {
         return null;
     return _jsx(Text, { color: theme.primary, children: "\u258C" });
 }
-export function Editor({ theme, model, disabled, running, onSubmit }) {
+export function Editor({ theme, model, disabled, running, onSubmit, onPauseFollow }) {
     const [value, setValue] = useState("");
     const [suggestions, setSuggestions] = useState([]);
     const [spinIdx, setSpinIdx] = useState(0);
@@ -60,6 +60,10 @@ export function Editor({ theme, model, disabled, running, onSubmit }) {
             }
             return;
         }
+        if ((key.pageUp || key.upArrow) && !key.ctrl && !key.meta) {
+            onPauseFollow?.();
+            return;
+        }
         if (key.backspace || key.delete) {
             const newVal = value.slice(0, -1);
             setValue(newVal);
@@ -74,5 +78,5 @@ export function Editor({ theme, model, disabled, running, onSubmit }) {
     }, { isActive: !disabled });
     const placeholder = "Ask anything…";
     const showCursor = !disabled && cursorOn;
-    return (_jsxs(Box, { flexDirection: "column", marginX: 2, children: [suggestions.length > 0 && (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.border, paddingX: 1, marginBottom: 1, children: suggestions.map((s) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.primary, children: s.cmd }), _jsxs(Text, { color: theme.textMuted, children: [" \u2014 ", s.desc] })] }, s.cmd))) })), _jsxs(Panel, { theme: theme, borderColor: disabled ? theme.border : theme.primary, marginBottom: 0, children: [_jsx(Box, { flexDirection: "row", children: value.length > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.text, children: value }), _jsx(BlinkingCursor, { theme: theme, visible: showCursor })] })) : showCursor ? (_jsx(BlinkingCursor, { theme: theme, visible: true })) : (_jsx(Text, { color: theme.textMuted, children: placeholder })) }), _jsxs(Text, { color: theme.textMuted, children: ["agent-dev \u00B7 ", _jsx(Text, { color: theme.text, children: modelRef(model) })] })] }), _jsx(Box, { marginTop: 1, marginBottom: 1, children: running ? (_jsxs(Text, { color: theme.textMuted, children: [_jsx(Text, { color: theme.primary, children: SPINNER_FRAMES[spinIdx] }), " ", "esc interrupt"] })) : (_jsx(Text, { color: theme.textMuted, children: "Tab completes /commands" })) })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginX: 2, children: [suggestions.length > 0 && (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.border, paddingX: 1, marginBottom: 1, children: suggestions.map((s) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.primary, children: s.cmd }), _jsxs(Text, { color: theme.textMuted, children: [" \u2014 ", s.desc] })] }, s.cmd))) })), _jsxs(Panel, { theme: theme, borderColor: disabled ? theme.border : theme.primary, marginBottom: 0, children: [_jsx(Box, { flexDirection: "row", children: value.length > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.text, children: value }), _jsx(BlinkingCursor, { theme: theme, visible: showCursor })] })) : showCursor ? (_jsx(BlinkingCursor, { theme: theme, visible: true })) : (_jsx(Text, { color: theme.textMuted, children: placeholder })) }), _jsxs(Text, { color: theme.textMuted, children: ["agent-dev \u00B7 ", _jsx(Text, { color: theme.text, children: modelRef(model) })] })] }), _jsx(Box, { marginTop: 1, marginBottom: 1, children: running ? (_jsxs(Text, { color: theme.textMuted, children: [_jsx(Text, { color: theme.primary, children: SPINNER_FRAMES[spinIdx] }), " ", "esc interrupt"] })) : (_jsx(Text, { color: theme.textMuted, children: "Tab completes /commands \u00B7 scroll freely \u00B7 Ctrl+G follow" })) })] }));
 }

package/dist/ui/layout.d.ts

@@ -0,0 +1,6 @@
+export interface TerminalSize {
+    rows: number;
+    cols: number;
+}
+export declare function useTerminalSize(): TerminalSize;
+export declare function chatContentWidth(cols: number): number;

package/dist/ui/layout.js

@@ -0,0 +1,22 @@
+import { useStdout } from "ink";
+import { useEffect, useState } from "react";
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({
+        rows: stdout.rows,
+        cols: stdout.columns,
+    });
+    useEffect(() => {
+        const onResize = () => {
+            setSize({ rows: stdout.rows, cols: stdout.columns });
+        };
+        stdout.on("resize", onResize);
+        return () => {
+            stdout.off("resize", onResize);
+        };
+    }, [stdout]);
+    return size;
+}
+export function chatContentWidth(cols) {
+    return Math.max(20, cols - 12);
+}

package/dist/ui/scroll.d.ts

@@ -0,0 +1,3 @@
+import type { WriteStream } from "node:tty";
+/** Nudge the terminal viewport toward the latest output (best-effort across terminals). */
+export declare function scrollViewportToBottom(stdout: WriteStream): void;

package/dist/ui/scroll.js

@@ -0,0 +1,4 @@
+/** Nudge the terminal viewport toward the latest output (best-effort across terminals). */
+export function scrollViewportToBottom(stdout) {
+    stdout.write("\x1b[999T");
+}

package/dist/ui/theme.js

@@ -19,4 +19,5 @@ export const TOOL_ICONS = {
     read: "→",
     write: "⚙",
     edit: "%",
+    web_search: "⌕",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devang0907/agent-dev",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Minimal terminal coding agent",
   "type": "module",
   "license": "MIT",