@devang0907/agent-dev 0.1.2 → 0.1.4

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/groq.js

@@ -1,4 +1,5 @@
 import OpenAI from "openai";
+import { toOpenAIMessages, toOpenAITools, processOpenAIStream, formatApiError, } from "./openai-compat.js";
 export const PROVIDER_ID = "groq";
 export const DEFAULT_MODEL = "llama-3.3-70b-versatile";
 export const API_KEY_ENV = "GROQ_API_KEY";
@@ -13,51 +14,6 @@ export function getApiKey(settings) {
 export function hasAuth(settings) {
     return !!getApiKey(settings);
 }
-function toOpenAIMessages(ctx) {
-    const msgs = [];
-    if (ctx.systemPrompt) {
-        msgs.push({ role: "system", content: ctx.systemPrompt });
-    }
-    for (const m of ctx.messages) {
-        if (m.role === "user") {
-            msgs.push({ role: "user", content: m.content });
-        }
-        else if (m.role === "assistant") {
-            if (m.toolCalls?.length) {
-                msgs.push({
-                    role: "assistant",
-                    content: m.content || null,
-                    tool_calls: m.toolCalls.map((tc) => ({
-                        id: tc.id,
-                        type: "function",
-                        function: { name: tc.name, arguments: tc.arguments },
-                    })),
-                });
-            }
-            else {
-                msgs.push({ role: "assistant", content: m.content });
-            }
-        }
-        else if (m.role === "tool") {
-            msgs.push({
-                role: "tool",
-                tool_call_id: m.toolCallId,
-                content: m.content,
-            });
-        }
-    }
-    return msgs;
-}
-function toOpenAITools(tools) {
-    return tools.map((t) => ({
-        type: "function",
-        function: {
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters,
-        },
-    }));
-}
 export async function* streamChat(model, ctx, settings) {
     const apiKey = getApiKey(settings);
     if (!apiKey) {
@@ -65,49 +21,19 @@ export async function* streamChat(model, ctx, settings) {
         return;
     }
     const client = new OpenAI({ apiKey, baseURL: BASE_URL });
+    const hasTools = ctx.tools.length > 0;
     try {
         const stream = await client.chat.completions.create({
             model: model.id,
             messages: toOpenAIMessages(ctx),
-            tools: ctx.tools.length > 0 ? toOpenAITools(ctx.tools) : undefined,
+            tools: hasTools ? toOpenAITools(ctx.tools) : undefined,
+            tool_choice: hasTools ? "auto" : undefined,
+            parallel_tool_calls: false,
             stream: true,
         }, { signal: ctx.signal });
-        const toolCalls = new Map();
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta;
-            if (!delta)
-                continue;
-            if (delta.content) {
-                yield { type: "text_delta", delta: delta.content };
-            }
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    const idx = tc.index;
-                    if (!toolCalls.has(idx)) {
-                        toolCalls.set(idx, { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: "" });
-                    }
-                    const existing = toolCalls.get(idx);
-                    if (tc.id)
-                        existing.id = tc.id;
-                    if (tc.function?.name)
-                        existing.name = tc.function.name;
-                    if (tc.function?.arguments) {
-                        existing.arguments += tc.function.arguments;
-                        yield {
-                            type: "tool_call_delta",
-                            index: idx,
-                            id: existing.id,
-                            name: existing.name,
-                            argumentsDelta: tc.function.arguments,
-                        };
-                    }
-                }
-            }
-        }
-        yield { type: "done" };
+        yield* processOpenAIStream(stream);
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        yield { type: "error", message };
+        yield { type: "error", message: formatApiError(err) };
     }
 }

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

@@ -0,0 +1,10 @@
+import type OpenAI from "openai";
+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

@@ -0,0 +1,212 @@
+export function sanitizeToolParameters(params) {
+    return {
+        ...params,
+        type: "object",
+        additionalProperties: false,
+    };
+}
+export function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: sanitizeToolParameters(t.parameters),
+        },
+    }));
+}
+export function normalizeToolCalls(toolCalls) {
+    return toolCalls.map((tc, i) => ({
+        id: tc.id?.trim() || `call_${Date.now()}_${i}`,
+        name: tc.name,
+        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) {
+        msgs.push({ role: "system", content: ctx.systemPrompt });
+    }
+    for (const m of ctx.messages) {
+        if (m.role === "user") {
+            msgs.push({ role: "user", content: m.content });
+        }
+        else if (m.role === "assistant") {
+            if (m.toolCalls?.length) {
+                const toolCalls = normalizeToolCalls(m.toolCalls);
+                msgs.push({
+                    role: "assistant",
+                    content: m.content || null,
+                    tool_calls: toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    })),
+                });
+            }
+            else {
+                msgs.push({ role: "assistant", content: m.content });
+            }
+        }
+        else if (m.role === "tool") {
+            msgs.push({
+                role: "tool",
+                tool_call_id: m.toolCallId,
+                content: m.content,
+                ...(m.name ? { name: m.name } : {}),
+            });
+        }
+    }
+    return msgs;
+}
+export async function* processOpenAIStream(stream) {
+    const toolCalls = new Map();
+    for await (const chunk of stream) {
+        const choice = chunk.choices[0];
+        if (choice?.finish_reason === "tool_calls" || choice?.delta?.tool_calls) {
+            // normal path
+        }
+        const delta = choice?.delta;
+        if (!delta)
+            continue;
+        if (delta.content) {
+            yield { type: "text_delta", delta: delta.content };
+        }
+        if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+                const idx = tc.index ?? 0;
+                if (!toolCalls.has(idx)) {
+                    toolCalls.set(idx, { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: "" });
+                }
+                const existing = toolCalls.get(idx);
+                if (tc.id)
+                    existing.id = tc.id;
+                if (tc.function?.name)
+                    existing.name = tc.function.name;
+                if (tc.function?.arguments) {
+                    existing.arguments += tc.function.arguments;
+                    yield {
+                        type: "tool_call_delta",
+                        index: idx,
+                        id: existing.id,
+                        name: existing.name,
+                        argumentsDelta: tc.function.arguments,
+                    };
+                }
+            }
+        }
+        if (chunk.usage) {
+            yield {
+                type: "done",
+                usage: {
+                    inputTokens: chunk.usage.prompt_tokens,
+                    outputTokens: chunk.usage.completion_tokens,
+                },
+            };
+        }
+    }
+    yield { type: "done" };
+}
+export function formatApiError(err) {
+    const apiErr = err;
+    const failed = apiErr.error?.failed_generation;
+    const msg = apiErr.error?.message ?? apiErr.message ?? "API error";
+    if (failed)
+        return `${msg}\nModel output: ${failed.slice(0, 300)}`;
+    return msg;
+}