@devang0907/agent-dev 0.1.2 → 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,8 +1,111 @@
+import { normalizeToolCalls, parseMalformedToolCalls, extractFailedGeneration, } from "../providers/openai-compat.js";
 import { streamChat } from "../providers/registry.js";
-import { getToolDefinitions, executeTool } from "./tools/index.js";
-const DEFAULT_SYSTEM_PROMPT = `You are a helpful coding assistant with access to tools: read, write, edit, and bash.
-Use tools to inspect and modify the codebase. Be concise and accurate.
-Working directory: ${process.cwd()}`;
+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, 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.
+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);
+}
+function hadSuccessfulToolResults(context) {
+    return context.some((m) => m.role === "tool" && m.content.length > 0 && !m.content.startsWith("Error:"));
+}
+function toolSignature(name, args) {
+    return `${name}:${JSON.stringify(args)}`;
+}
+function dedupeToolCalls(toolCalls) {
+    const seen = new Set();
+    return toolCalls.filter((tc) => {
+        const key = `${tc.name}:${tc.arguments}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        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 = "";
@@ -32,51 +135,64 @@ 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 = Array.from(toolCallMap.values()).filter((tc) => tc.name);
+    const toolCalls = normalizeToolCalls(Array.from(toolCallMap.values()).filter((tc) => tc.name));
     return { content, toolCalls };
 }
+function finishGracefully(context, content, onEvent) {
+    const msg = content.trim() || "Done — changes saved successfully.";
+    if (!content.trim()) {
+        onEvent({ type: "text_delta", delta: msg });
+    }
+    context.push({ role: "assistant", content: msg });
+    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)
             break;
+        toolRound++;
+        if (toolRound > MAX_TOOL_ROUNDS) {
+            finishGracefully(context, "Done — stopped after too many tool calls.", onEvent);
+            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;
+            }
             onEvent({ type: "error", message: error });
             break;
         }
         const assistantMsg = {
             role: "assistant",
-            content,
-            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            content: error ? "" : content,
+            toolCalls: uniqueCalls.length > 0 ? uniqueCalls : undefined,
         };
         context.push(assistantMsg);
-        if (toolCalls.length === 0) {
-            onEvent({ type: "turn_end" });
-            break;
-        }
-        for (const tc of toolCalls) {
-            onEvent({ type: "tool_call", toolCall: tc });
-            let args = {};
-            try {
-                args = JSON.parse(tc.arguments || "{}");
+        if (uniqueCalls.length === 0) {
+            if (error) {
+                onEvent({ type: "error", message: error });
             }
-            catch {
-                args = {};
+            else {
+                onEvent({ type: "turn_end" });
             }
-            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,
-            });
+            break;
+        }
+        const stopAfterBatch = await runToolBatch(uniqueCalls, context, workdir, callCounts, onEvent, onPermissionRequest);
+        if (stopAfterBatch) {
+            finishGracefully(context, content, onEvent);
+            break;
         }
     }
     return context.slice(messages.length);

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);
@@ -20,6 +23,7 @@ export const readTool = {
             path: { type: "string", description: "File path relative to project root" },
         },
         required: ["path"],
+        additionalProperties: false,
     },
 };
 export async function executeRead(args, workdir = DEFAULT_WORKDIR) {
@@ -41,6 +45,7 @@ export const writeTool = {
             content: { type: "string", description: "Content to write" },
         },
         required: ["path", "content"],
+        additionalProperties: false,
     },
 };
 export async function executeWrite(args, workdir = DEFAULT_WORKDIR) {
@@ -60,6 +65,7 @@ export const editTool = {
             new_string: { type: "string", description: "Replacement string" },
         },
         required: ["path", "old_string", "new_string"],
+        additionalProperties: false,
     },
 };
 export async function executeEdit(args, workdir = DEFAULT_WORKDIR) {
@@ -78,31 +84,23 @@ 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: {
             command: { type: "string", description: "Shell command to execute" },
         },
         required: ["command"],
+        additionalProperties: false,
     },
 };
 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>;