@devang0907/agent-dev 0.1.3 → 0.1.5

package/dist/agent/tools/search.js

@@ -0,0 +1,229 @@
+export const webSearchTool = {
+    name: "web_search",
+    description: "Search the internet for news, documentation, or current information",
+    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";
+const NEWS_QUERY_RE = /\b(news|headlines|breaking news|top\s+\d+\s+(news|stories|headlines)|\d+\s+news|today'?s?\s+(news|headlines|\d+\s+news))\b/i;
+function isNewsQuery(query) {
+    return NEWS_QUERY_RE.test(query);
+}
+function headlineLimit(query) {
+    const top = query.match(/\btop\s+(\d+)\b/i);
+    if (top)
+        return Math.min(50, Math.max(1, parseInt(top[1], 10)));
+    const n = query.match(/\b(\d+)\s+news\b/i);
+    if (n)
+        return Math.min(50, Math.max(1, parseInt(n[1], 10)));
+    return 20;
+}
+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 extractXmlTag(block, tag) {
+    const cdata = block.match(new RegExp(`<${tag}><!\\[CDATA\\[([\\s\\S]*?)\\]\\]><\\/${tag}>`))?.[1];
+    if (cdata)
+        return cdata.trim();
+    return block.match(new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`))?.[1]?.trim() ?? "";
+}
+function parseRssItems(xml, limit) {
+    const results = [];
+    const itemRe = /<item>([\s\S]*?)<\/item>/gi;
+    let match;
+    while ((match = itemRe.exec(xml)) !== null && results.length < limit) {
+        const block = match[1];
+        const title = stripHtml(extractXmlTag(block, "title"));
+        const url = extractXmlTag(block, "link");
+        const pubDate = extractXmlTag(block, "pubDate");
+        const snippet = stripHtml(extractXmlTag(block, "description")).slice(0, 200);
+        if (title && url) {
+            results.push({ title, url, snippet, pubDate });
+        }
+    }
+    return results;
+}
+async function fetchGoogleNewsHeadlines(limit) {
+    const url = "https://news.google.com/rss?hl=en-US&gl=US&ceid=US:en";
+    const res = await fetch(url, {
+        headers: { "User-Agent": USER_AGENT },
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        throw new Error(`Google News RSS failed (${res.status})`);
+    return parseRssItems(await res.text(), limit);
+}
+async function fetchGoogleNewsSearch(query, limit) {
+    const url = `https://news.google.com/rss/search?q=${encodeURIComponent(query)}&hl=en-US&gl=US&ceid=US:en`;
+    const res = await fetch(url, {
+        headers: { "User-Agent": USER_AGENT },
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        throw new Error(`Google News search RSS failed (${res.status})`);
+    return parseRssItems(await res.text(), limit);
+}
+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 isAdOrJunk(result) {
+    const url = result.url.toLowerCase();
+    return (url.includes("ad_provider") ||
+        url.includes("ad_domain") ||
+        url.includes("duckduckgo.com/y.") ||
+        url.length > 280);
+}
+function cleanResultUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return `${parsed.origin}${parsed.pathname}`;
+    }
+    catch {
+        return url.length > 120 ? url.slice(0, 120) + "…" : url;
+    }
+}
+function parseTagsByClass(html, className) {
+    const re = new RegExp(`<a\\b[^>]*class=['"]${className}['"][^>]*>[\\s\\S]*?<\\/a>`, "gi");
+    return html.match(re) ?? [];
+}
+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 < 15; 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 && !isAdOrJunk({ title, url: decodeDdgUrl(href), snippet })) {
+            results.push({ title, url: cleanResultUrl(decodeDdgUrl(href)), snippet });
+        }
+    }
+    return results;
+}
+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: "us-en" }),
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        throw new Error(`DuckDuckGo html failed (${res.status})`);
+    return parseDdgHtmlResults(await res.text());
+}
+function dedupeResults(results) {
+    const seen = new Set();
+    return results.filter((r) => {
+        const key = r.title.toLowerCase().slice(0, 60);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+async function fetchNewsResults(query) {
+    const limit = headlineLimit(query);
+    const generic = /\b(top\s+\d+|today'?s?\s+news|news of today|news today|latest news|breaking news)\b/i.test(query);
+    let results;
+    if (generic) {
+        results = await fetchGoogleNewsHeadlines(limit);
+    }
+    else {
+        results = await fetchGoogleNewsSearch(query, limit);
+        if (results.length < 5) {
+            results = [...results, ...(await fetchGoogleNewsHeadlines(limit))];
+        }
+    }
+    return dedupeResults(results).slice(0, limit);
+}
+async function fetchWebResults(query) {
+    return dedupeResults(await fetchDdgHtmlResults(query)).slice(0, 12);
+}
+function formatNewsResults(query, items) {
+    const lines = [
+        `Headlines for: ${query}`,
+        `Source: Google News (US, ${new Date().toISOString().slice(0, 10)})`,
+        "",
+    ];
+    if (items.length === 0) {
+        lines.push("No headlines found.");
+        return lines.join("\n");
+    }
+    for (const [i, item] of items.entries()) {
+        lines.push(`${i + 1}. ${item.title}`);
+        if (item.pubDate)
+            lines.push(`   ${item.pubDate}`);
+    }
+    lines.push("");
+    lines.push("Reply with a numbered list using these exact headline titles. Add a one-line note only if a headline is unclear.");
+    return lines.join("\n");
+}
+function formatWebResults(query, web) {
+    const lines = [`Search results for: ${query}`, ""];
+    if (web.length === 0) {
+        lines.push("No results found.");
+        return lines.join("\n");
+    }
+    for (const [i, r] of web.entries()) {
+        lines.push(`${i + 1}. ${r.title}`);
+        lines.push(`   ${r.url}`);
+        if (r.snippet)
+            lines.push(`   ${r.snippet.slice(0, 160)}`);
+    }
+    lines.push("");
+    lines.push("Summarize the key findings for the user concisely.");
+    return lines.join("\n");
+}
+export async function executeWebSearch(args) {
+    const query = args.query?.trim();
+    if (!query)
+        return "Error: query is required";
+    try {
+        if (isNewsQuery(query)) {
+            const headlines = await fetchNewsResults(query);
+            return formatNewsResults(query, headlines);
+        }
+        const web = await fetchWebResults(query);
+        return formatWebResults(query, 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,131 @@
+import { spawn } from "node:child_process";
+import { platform as osPlatform } from "node:os";
+import { getShellConfig, normalizeCommand } from "../platform.js";
+const DEFAULT_TIMEOUT_MS = 120_000;
+const INSTALL_TIMEOUT_MS = 300_000;
+const DEV_SERVER_BOOT_MS = 20_000;
+const DEV_SERVER_RE = /\b(npm run dev|npm start|yarn dev|pnpm dev|next dev|nuxt dev|vite(\s|$)|react-scripts start)\b/i;
+const INSTALL_RE = /\b(npm install|npm ci|yarn install|pnpm install|npx create-|npm audit)\b/i;
+const READY_RE = /https?:\/\/(?:localhost|127\.0\.0\.1):\d+|localhost:\d+|Local:\s*https?:\/\/[^\s]+|ready in \d|started server on|compiled successfully/i;
+const backgroundProcesses = new Map();
+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);
+}
+function extractUrl(output) {
+    const http = output.match(/https?:\/\/(?:localhost|127\.0\.0\.1):\d+/i);
+    if (http)
+        return http[0];
+    const local = output.match(/localhost:\d+/i);
+    if (local)
+        return `http://${local[0]}`;
+    return "http://localhost:3000";
+}
+function killHint(pid) {
+    return osPlatform() === "win32"
+        ? `Stop: taskkill /PID ${pid} /F`
+        : `Stop: kill ${pid}`;
+}
+async function runDevServerInBackground(command, workdir, shell) {
+    const normalized = normalizeCommand(command, shell);
+    const args = [...shell.args, normalized];
+    return new Promise((resolve) => {
+        let output = "";
+        let settled = false;
+        const finish = (message) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(message);
+        };
+        const child = spawn(shell.executable, args, {
+            cwd: workdir,
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, FORCE_COLOR: "0", BROWSER: "none" },
+            windowsHide: true,
+        });
+        if (!child.pid) {
+            finish("Error: failed to start dev server process");
+            return;
+        }
+        const pid = child.pid;
+        backgroundProcesses.set(pid, child);
+        child.on("exit", () => {
+            backgroundProcesses.delete(pid);
+        });
+        const onData = (chunk) => {
+            output += String(chunk);
+            if (READY_RE.test(output)) {
+                clearTimeout(bootTimer);
+                child.stdout?.off("data", onData);
+                child.stderr?.off("data", onData);
+                child.unref();
+                const url = extractUrl(output);
+                finish(`Dev server started in background (PID ${pid}).\nOpen ${url}\n${killHint(pid)}`);
+            }
+        };
+        child.stdout?.on("data", onData);
+        child.stderr?.on("data", onData);
+        child.on("error", (err) => {
+            backgroundProcesses.delete(pid);
+            finish(`Error: ${err.message}`);
+        });
+        const bootTimer = setTimeout(() => {
+            child.stdout?.off("data", onData);
+            child.stderr?.off("data", onData);
+            child.unref();
+            const url = extractUrl(output);
+            finish(`Dev server starting in background (PID ${pid}).\nLikely URL: ${url}\n${killHint(pid)}`);
+        }, DEV_SERVER_BOOT_MS);
+    });
+}
+export async function executeShellCommand(command, workdir) {
+    const shell = getShellConfig();
+    const normalized = normalizeCommand(command, shell);
+    if (isDevServerCommand(normalized)) {
+        return runDevServerInBackground(normalized, workdir, shell);
+    }
+    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)}`.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,104 @@ 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 stripToolArgWrapper(raw) {
+    let body = raw.trim().replace(/^[\[\]=\s]+/, "");
+    if (body.startsWith("(") && body.endsWith(")")) {
+        body = body.slice(1, -1).trim();
+    }
+    return body;
+}
+function argsFromFunctionTail(tail) {
+    const jsonIdx = tail.indexOf("{");
+    if (jsonIdx < 0)
+        return null;
+    return parseToolArguments(tail.slice(jsonIdx));
+}
+function parseToolArguments(raw) {
+    const body = stripToolArgWrapper(raw);
+    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 truncatedQuery = body.match(/"query"\s*:\s*"([\s\S]+)$/);
+    if (truncatedQuery) {
+        const query = unescapeJsonString(truncatedQuery[1].replace(/\\+$/, ""));
+        return JSON.stringify({ query });
+    }
+    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 tryAdd = (name, tail) => {
+        const args = argsFromFunctionTail(tail);
+        if (name && args)
+            pushRecovered(results, name, args);
+    };
+    const closedRe = /<function=([a-zA-Z0-9_]+)([\s\S]*?)<\/function>/gi;
+    let match;
+    while ((match = closedRe.exec(text)) !== null) {
+        tryAdd(match[1].trim(), match[2]);
+    }
+    if (results.length === 0) {
+        const truncatedRe = /<function=([a-zA-Z0-9_]+)([\s\S]+)/gi;
+        while ((match = truncatedRe.exec(text)) !== null) {
+            tryAdd(match[1].trim(), match[2]);
+        }
+    }
+    if (results.length === 0) {
+        const toolCallRe = /<tool_call>\s*([a-zA-Z0-9_]+)([\s\S]*?)<\/tool_call>/gi;
+        while ((match = toolCallRe.exec(text)) !== null) {
+            tryAdd(match[1].trim(), match[2]);
+        }
+    }
+    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;