@hasna/oldpal 0.1.6 → 0.1.8

package/dist/index.js

@@ -29187,6 +29187,194 @@ class FilesystemTools {
   };
 }
 
+// packages/core/src/tools/web.ts
+class WebFetchTool {
+  static tool = {
+    name: "web_fetch",
+    description: "Fetch content from a URL and return the text content. Useful for reading web pages, documentation, API responses, etc.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch content from"
+        },
+        extract_type: {
+          type: "string",
+          description: 'What to extract: "text" for readable text, "html" for raw HTML, "json" for JSON response',
+          enum: ["text", "html", "json"],
+          default: "text"
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (default: 30000)"
+        }
+      },
+      required: ["url"]
+    }
+  };
+  static executor = async (input) => {
+    const url = input.url;
+    const extractType = input.extract_type || "text";
+    const timeout = input.timeout || 30000;
+    try {
+      const parsedUrl = new URL(url);
+      const hostname = parsedUrl.hostname;
+      if (hostname === "localhost" || hostname === "127.0.0.1" || hostname.startsWith("192.168.") || hostname.startsWith("10.") || hostname.startsWith("172.")) {
+        return "Error: Cannot fetch from local/private network addresses for security reasons";
+      }
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "oldpal/1.0 (AI Assistant)",
+          Accept: extractType === "json" ? "application/json" : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return `Error: HTTP ${response.status} ${response.statusText}`;
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (extractType === "json") {
+        try {
+          const json = await response.json();
+          return JSON.stringify(json, null, 2);
+        } catch {
+          return "Error: Response is not valid JSON";
+        }
+      }
+      const html = await response.text();
+      if (extractType === "html") {
+        const maxLength2 = 50000;
+        if (html.length > maxLength2) {
+          return html.slice(0, maxLength2) + `
+
+[Content truncated...]`;
+        }
+        return html;
+      }
+      const text = extractReadableText(html);
+      const maxLength = 30000;
+      if (text.length > maxLength) {
+        return text.slice(0, maxLength) + `
+
+[Content truncated...]`;
+      }
+      return text || "No readable content found on page";
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          return `Error: Request timed out after ${timeout}ms`;
+        }
+        return `Error: ${error.message}`;
+      }
+      return `Error: ${String(error)}`;
+    }
+  };
+}
+
+class WebSearchTool {
+  static tool = {
+    name: "web_search",
+    description: "Search the web using DuckDuckGo and return results. Useful for finding current information, documentation, news, etc.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query"
+        },
+        max_results: {
+          type: "number",
+          description: "Maximum number of results to return (default: 5, max: 10)"
+        }
+      },
+      required: ["query"]
+    }
+  };
+  static executor = async (input) => {
+    const query = input.query;
+    const maxResults = Math.min(input.max_results || 5, 10);
+    try {
+      const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      const response = await fetch(searchUrl, {
+        headers: {
+          "User-Agent": "oldpal/1.0 (AI Assistant)",
+          Accept: "text/html"
+        }
+      });
+      if (!response.ok) {
+        return `Error: Search request failed with HTTP ${response.status}`;
+      }
+      const html = await response.text();
+      const results = parseDuckDuckGoResults(html, maxResults);
+      if (results.length === 0) {
+        return `No results found for "${query}"`;
+      }
+      let output = `Search results for "${query}":
+
+`;
+      for (let i = 0;i < results.length; i++) {
+        const r = results[i];
+        output += `${i + 1}. ${r.title}
+`;
+        output += `   ${r.url}
+`;
+        if (r.snippet) {
+          output += `   ${r.snippet}
+`;
+        }
+        output += `
+`;
+      }
+      return output.trim();
+    } catch (error) {
+      return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  };
+}
+function extractReadableText(html) {
+  let text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<noscript[^>]*>[\s\S]*?<\/noscript>/gi, "").replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, "").replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, "").replace(/<header[^>]*>[\s\S]*?<\/header>/gi, "");
+  text = text.replace(/<\/?(p|div|br|h[1-6]|li|tr|blockquote)[^>]*>/gi, `
+`).replace(/<\/?[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/\s+/g, " ").replace(/\n\s*\n/g, `
+
+`).trim();
+  return text;
+}
+function parseDuckDuckGoResults(html, maxResults) {
+  const results = [];
+  const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([^<]*)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([^<]*)/gi;
+  let match;
+  while ((match = resultRegex.exec(html)) !== null && results.length < maxResults) {
+    const url = decodeURIComponent(match[1].replace(/\/l\/\?uddg=/, "").split("&")[0]);
+    const title = match[2].trim();
+    const snippet = match[3].trim().replace(/&[^;]+;/g, " ");
+    if (url && title && !url.startsWith("//duckduckgo.com")) {
+      results.push({ title, url, snippet });
+    }
+  }
+  if (results.length === 0) {
+    const simpleRegex = /<a[^>]*href="(https?:\/\/[^"]+)"[^>]*class="[^"]*result[^"]*"[^>]*>([^<]+)/gi;
+    while ((match = simpleRegex.exec(html)) !== null && results.length < maxResults) {
+      const url = match[1];
+      const title = match[2].trim();
+      if (url && title) {
+        results.push({ title, url, snippet: "" });
+      }
+    }
+  }
+  return results;
+}
+
+class WebTools {
+  static registerAll(registry) {
+    registry.register(WebFetchTool.tool, WebFetchTool.executor);
+    registry.register(WebSearchTool.tool, WebSearchTool.executor);
+  }
+}
+
 // packages/core/src/skills/loader.ts
 import { join as join3 } from "path";
 import { homedir as homedir2 } from "os";
@@ -29605,6 +29793,7 @@ class AgentLoop {
     this.llmClient = await createLLMClient(this.config.llm);
     this.toolRegistry.register(BashTool.tool, BashTool.executor);
     FilesystemTools.registerAll(this.toolRegistry);
+    WebTools.registerAll(this.toolRegistry);
     await this.connectorBridge.discover(this.config.connectors);
     this.connectorBridge.registerAll(this.toolRegistry);
     await this.skillLoader.loadAll(this.cwd);
@@ -30073,26 +30262,50 @@ var build_default = TextInput;
 
 // packages/terminal/src/components/Input.tsx
 var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
-function Input({ onSubmit, disabled }) {
+function Input({ onSubmit, isProcessing, queueLength = 0 }) {
   const [value, setValue] = import_react23.useState("");
+  use_input_default((input, key) => {
+    if (!value.trim())
+      return;
+    if ((key.shift || key.ctrl) && key.return) {
+      onSubmit(value, "interrupt");
+      setValue("");
+    } else if (key.meta && key.return) {
+      onSubmit(value, "queue");
+      setValue("");
+    }
+  });
   const handleSubmit = (submittedValue) => {
-    if (disabled || !submittedValue.trim())
+    if (!submittedValue.trim())
       return;
-    onSubmit(submittedValue);
+    if (isProcessing) {
+      onSubmit(submittedValue, "queue");
+    } else {
+      onSubmit(submittedValue, "normal");
+    }
     setValue("");
   };
+  let prompt = "\u276F";
+  let placeholder = "Type a message...";
+  if (isProcessing) {
+    prompt = "\u22EF";
+    placeholder = queueLength > 0 ? "Type to queue another..." : "Type to queue (Enter) or interrupt (Shift+Enter)...";
+  }
   return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
     marginTop: 1,
     children: [
       /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
-        dimColor: disabled,
-        children: "\u276F "
-      }, undefined, false, undefined, this),
+        dimColor: isProcessing,
+        children: [
+          prompt,
+          " "
+        ]
+      }, undefined, true, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime.jsxDEV(build_default, {
         value,
         onChange: setValue,
         onSubmit: handleSubmit,
-        placeholder: disabled ? "" : "Type a message..."
+        placeholder
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
@@ -30134,7 +30347,7 @@ function parseMarkdown(text) {
 
 // packages/terminal/src/components/Messages.tsx
 var jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
-function Messages4({ messages, currentResponse, currentToolCall, lastToolResult }) {
+function Messages4({ messages, currentResponse, currentToolCall, lastToolResult, activityLog = [] }) {
   const visibleMessages = messages.slice(-15);
   return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
     flexDirection: "column",
@@ -30142,7 +30355,37 @@ function Messages4({ messages, currentResponse, currentToolCall, lastToolResult
       visibleMessages.map((message) => /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(MessageBubble, {
         message
       }, message.id, false, undefined, this)),
-      currentToolCall && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+      activityLog.map((entry) => {
+        if (entry.type === "tool_call" && entry.toolCall) {
+          return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+            marginY: 1,
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+                dimColor: true,
+                children: "\u25D0 "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+                dimColor: true,
+                children: formatToolCall(entry.toolCall)
+              }, undefined, false, undefined, this)
+            ]
+          }, entry.id, true, undefined, this);
+        }
+        if (entry.type === "tool_result" && entry.toolResult) {
+          return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+            marginLeft: 2,
+            children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+              dimColor: true,
+              children: [
+                "\u2192 ",
+                truncate(entry.toolResult.content, 100)
+              ]
+            }, undefined, true, undefined, this)
+          }, entry.id, false, undefined, this);
+        }
+        return null;
+      }),
+      currentToolCall && !activityLog.some((e) => e.toolCall?.id === currentToolCall.id) && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
         marginY: 1,
         children: [
           /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
@@ -30155,7 +30398,7 @@ function Messages4({ messages, currentResponse, currentToolCall, lastToolResult
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      lastToolResult && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+      lastToolResult && !activityLog.some((e) => e.toolResult?.toolCallId === lastToolResult.toolCallId) && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
         marginY: 1,
         marginLeft: 2,
         children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
@@ -30273,9 +30516,10 @@ function truncate(text, maxLength) {
 
 // packages/terminal/src/components/Status.tsx
 var jsx_dev_runtime4 = __toESM(require_jsx_dev_runtime(), 1);
-function Status({ isProcessing, cwd: cwd2 }) {
+function Status({ isProcessing, cwd: cwd2, queueLength = 0 }) {
   const maxCwdLength = 50;
   const displayCwd = cwd2.length > maxCwdLength ? "..." + cwd2.slice(-(maxCwdLength - 3)) : cwd2;
+  const queueInfo = queueLength > 0 ? ` | ${queueLength} queued` : "";
   return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     marginTop: 1,
     borderStyle: "single",
@@ -30293,11 +30537,15 @@ function Status({ isProcessing, cwd: cwd2 }) {
             dimColor: !isProcessing,
             children: isProcessing ? "\u25CF processing" : "\u25CF ready"
           }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
+            dimColor: true,
+            children: queueInfo
+          }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
             dimColor: true,
             children: [
-              " | Ctrl+C to ",
-              isProcessing ? "stop" : "exit"
+              " | ",
+              isProcessing ? "Esc to stop" : "Ctrl+C to exit"
             ]
           }, undefined, true, undefined, this)
         ]
@@ -30361,37 +30609,90 @@ function App2({ cwd: cwd2 }) {
   const [isProcessing, setIsProcessing] = import_react25.useState(false);
   const [isInitializing, setIsInitializing] = import_react25.useState(true);
   const [error, setError] = import_react25.useState(null);
+  const [messageQueue, setMessageQueue] = import_react25.useState([]);
+  const [activityLog, setActivityLog] = import_react25.useState([]);
   const responseRef = import_react25.useRef("");
+  const clientRef = import_react25.useRef(null);
+  const toolCallsRef = import_react25.useRef([]);
+  const toolResultsRef = import_react25.useRef([]);
+  const processQueue = import_react25.useCallback(async () => {
+    if (!clientRef.current || messageQueue.length === 0)
+      return;
+    const nextMessage = messageQueue[0];
+    setMessageQueue((prev) => prev.slice(1));
+    const userMessage = {
+      id: generateId(),
+      role: "user",
+      content: nextMessage,
+      timestamp: now()
+    };
+    setMessages((prev) => [...prev, userMessage]);
+    setCurrentResponse("");
+    responseRef.current = "";
+    toolCallsRef.current = [];
+    toolResultsRef.current = [];
+    setError(null);
+    setCurrentToolCall(undefined);
+    setLastToolResult(undefined);
+    setActivityLog([]);
+    setIsProcessing(true);
+    await clientRef.current.send(nextMessage);
+  }, [messageQueue]);
   import_react25.useEffect(() => {
     const initClient = async () => {
       try {
         const newClient = new EmbeddedClient(cwd2);
+        clientRef.current = newClient;
         newClient.onChunk((chunk) => {
           if (chunk.type === "text" && chunk.content) {
             responseRef.current += chunk.content;
             setCurrentResponse(responseRef.current);
           } else if (chunk.type === "tool_use" && chunk.toolCall) {
+            toolCallsRef.current.push(chunk.toolCall);
+            setActivityLog((prev) => [
+              ...prev,
+              {
+                id: generateId(),
+                type: "tool_call",
+                toolCall: chunk.toolCall,
+                timestamp: now()
+              }
+            ]);
             setCurrentToolCall(chunk.toolCall);
             setLastToolResult(undefined);
           } else if (chunk.type === "tool_result" && chunk.toolResult) {
+            toolResultsRef.current.push(chunk.toolResult);
+            setActivityLog((prev) => [
+              ...prev,
+              {
+                id: generateId(),
+                type: "tool_result",
+                toolResult: chunk.toolResult,
+                timestamp: now()
+              }
+            ]);
             setLastToolResult(chunk.toolResult);
             setCurrentToolCall(undefined);
           } else if (chunk.type === "error" && chunk.error) {
             setError(chunk.error);
             setIsProcessing(false);
           } else if (chunk.type === "done") {
-            if (responseRef.current) {
+            if (responseRef.current || toolCallsRef.current.length > 0) {
               setMessages((prev) => [
                 ...prev,
                 {
                   id: generateId(),
                   role: "assistant",
                   content: responseRef.current,
-                  timestamp: now()
+                  timestamp: now(),
+                  toolCalls: toolCallsRef.current.length > 0 ? [...toolCallsRef.current] : undefined,
+                  toolResults: toolResultsRef.current.length > 0 ? [...toolResultsRef.current] : undefined
                 }
               ]);
               setCurrentResponse("");
               responseRef.current = "";
+              toolCallsRef.current = [];
+              toolResultsRef.current = [];
             }
             setCurrentToolCall(undefined);
             setLastToolResult(undefined);
@@ -30412,20 +30713,83 @@ function App2({ cwd: cwd2 }) {
     };
     initClient();
   }, [cwd2]);
+  import_react25.useEffect(() => {
+    if (!isProcessing && messageQueue.length > 0) {
+      processQueue();
+    }
+  }, [isProcessing, messageQueue.length, processQueue]);
   use_input_default((input, key) => {
     if (key.ctrl && input === "c") {
       if (isProcessing && client) {
         client.stop();
+        if (responseRef.current) {
+          setMessages((prev) => [
+            ...prev,
+            {
+              id: generateId(),
+              role: "assistant",
+              content: responseRef.current + `
+
+[stopped]`,
+              timestamp: now()
+            }
+          ]);
+          setCurrentResponse("");
+          responseRef.current = "";
+        }
         setIsProcessing(false);
       } else {
         exit();
       }
     }
+    if (key.escape && isProcessing && client) {
+      client.stop();
+      if (responseRef.current) {
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: generateId(),
+            role: "assistant",
+            content: responseRef.current + `
+
+[stopped]`,
+            timestamp: now()
+          }
+        ]);
+        setCurrentResponse("");
+        responseRef.current = "";
+      }
+      setIsProcessing(false);
+    }
   });
-  const handleSubmit = import_react25.useCallback(async (input) => {
-    if (!client || !input.trim() || isProcessing)
+  const handleSubmit = import_react25.useCallback(async (input, mode = "normal") => {
+    if (!client || !input.trim())
       return;
     const trimmedInput = input.trim();
+    if (mode === "queue" || isProcessing && mode === "normal") {
+      setMessageQueue((prev) => [...prev, trimmedInput]);
+      return;
+    }
+    if (mode === "interrupt" && isProcessing) {
+      client.stop();
+      if (responseRef.current) {
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: generateId(),
+            role: "assistant",
+            content: responseRef.current + `
+
+[interrupted]`,
+            timestamp: now()
+          }
+        ]);
+      }
+      setCurrentResponse("");
+      responseRef.current = "";
+      setIsProcessing(false);
+      await new Promise((r) => setTimeout(r, 100));
+    }
     const userMessage = {
       id: generateId(),
       role: "user",
@@ -30435,9 +30799,12 @@ function App2({ cwd: cwd2 }) {
     setMessages((prev) => [...prev, userMessage]);
     setCurrentResponse("");
     responseRef.current = "";
+    toolCallsRef.current = [];
+    toolResultsRef.current = [];
     setError(null);
     setCurrentToolCall(undefined);
     setLastToolResult(undefined);
+    setActivityLog([]);
     setIsProcessing(true);
     await client.send(trimmedInput);
   }, [client, isProcessing]);
@@ -30458,7 +30825,20 @@ function App2({ cwd: cwd2 }) {
         messages,
         currentResponse: isProcessing ? currentResponse : undefined,
         currentToolCall,
-        lastToolResult
+        lastToolResult,
+        activityLog: isProcessing ? activityLog : []
+      }, undefined, false, undefined, this),
+      messageQueue.length > 0 && /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+        marginY: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
+          dimColor: true,
+          children: [
+            messageQueue.length,
+            " message",
+            messageQueue.length > 1 ? "s" : "",
+            " queued"
+          ]
+        }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
       error && /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
         marginY: 1,
@@ -30478,11 +30858,13 @@ function App2({ cwd: cwd2 }) {
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Input, {
         onSubmit: handleSubmit,
-        disabled: isProcessing
+        isProcessing,
+        queueLength: messageQueue.length
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Status, {
         isProcessing,
-        cwd: cwd2
+        cwd: cwd2,
+        queueLength: messageQueue.length
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
@@ -30497,7 +30879,7 @@ var options = {
   help: args.includes("--help") || args.includes("-h")
 };
 if (options.version) {
-  console.log("oldpal v0.1.6");
+  console.log("oldpal v0.1.8");
   process.exit(0);
 }
 if (options.help) {
@@ -30528,4 +30910,4 @@ waitUntilExit().then(() => {
   process.exit(0);
 });
 
-//# debugId=F294B9F3A80B4E7C64756E2164756E21
+//# debugId=43BB59ABD8BF8C1564756E2164756E21