Add Jina API integration with fetch utility functions for page reading and searching

PrashamTrivedi · PrashamTrivedi · commit 0377ff18d889 · 2025-01-24T22:01:39.000+05:30
diff --git a/src/commands/settings.ts b/src/commands/settings.ts
@@ -1,10 +1,10 @@
 import {parseArgs} from "jsr:@std/cli/parse-args"
 import {loadUserSettings, saveUserSettings} from "../config/settings.ts"
-import {parseFlagForHelp} from "../utils/functions.ts"
+import {parseFlagForHelp, getCommandHelp} from "../utils/functions.ts"
 
 export async function handleSettings(args: string[]): Promise<void> {
     const settingsFlags = {
-        string: ["set-name", "add-command", "remove-command"],
+        string: ["set-name", "add-command", "remove-command", "set-jina-key"],
         boolean: ["list"],
     }
     const flags = parseArgs(args, settingsFlags)
@@ -18,18 +18,42 @@ export async function handleSettings(args: string[]): Promise<void> {
     if (flags["set-name"]) {
         settings.userName = flags["set-name"]
     }
+    else if (flags["set-jina-key"]) {
+        settings.jinaApiKey = flags["set-jina-key"]
+        console.log("Jina API key has been set")
+    }
     else if (flags["add-command"]) {
-        const addCommandValue = flags["add-command"] as string;
-        const [name, description, helpCmd, ...helpFlags] = addCommandValue.split(",")
-        settings.customCommands.push({
-            name,
-            description,
-            helpCommand: helpCmd,
-            helpFlags: helpFlags
-        })
+        const commandNameFromArg = flags["add-command"] as string
+        let commandName = commandNameFromArg
+        let commandDescription = ""
+        if (commandNameFromArg.includes(",")) {
+            const commandSplit = commandNameFromArg.split(",")
+            commandName = commandSplit[0]
+            commandDescription = commandSplit[1]
+        }
+        const helpInfo = await getCommandHelp(commandName)
+        console.log(`Got help info for ${commandName}}`)
+
+        const existingCommandIndex = settings.customCommands.findIndex(cmd => cmd.name === commandName)
+        if (existingCommandIndex >= 0) {
+            settings.customCommands[existingCommandIndex] = {
+                name: commandName,
+                description: commandDescription || helpInfo.description,
+                helpText: helpInfo.helpText,
+            }
+        } else {
+            settings.customCommands.push({
+                name: commandName,
+                description: commandDescription || helpInfo.description,
+                helpText: helpInfo.helpText,
+            })
+        }
+        console.log(`Added command ${commandName} with help information`)
     }
     else if (flags["remove-command"]) {
-        const index = settings.customCommands.findIndex(cmd => cmd.name === flags["remove-command"])
+        const commandNameFromArg = flags["remove-command"] as string
+        const index = settings.customCommands.findIndex(cmd => cmd.name === commandNameFromArg)
+        console.log(`Removing command ${flags["remove-command"]} at index ${index}`)
         if (index >= 0) settings.customCommands.splice(index, 1)
     }
     else if (flags.list) {
diff --git a/src/config/constants.ts b/src/config/constants.ts
@@ -1,7 +1,7 @@
 import {join} from "jsr:@std/path"
 import Anthropic from "npm:@anthropic-ai/sdk"
 import {homedir} from "node:os"
-import {loadUserSettings} from "./settings.ts"
+import {isJinaAvailable, loadUserSettings} from "./settings.ts"
 
 export const EDITOR_DIR = join(homedir(), ".ComputerUseAgent", "editor_dir")
 export const SESSIONS_DIR = join(homedir(), ".ComputerUseAgent", "sessions")
@@ -63,6 +63,15 @@ You have access to following tools and capabilities:
 - CLIPBOARD_TOOLS:
     - Name: "read_clipboard"
     - Arguments: none
+${isJinaAvailable() ? `
+- JINA_TOOLS:
+    - Name: "readPage"
+    - Arguments: {url: string}
+    - Name: "search"
+    - Arguments: {searchTerm: string}
+    - Name: "searchGrounding"
+    - Arguments: {searchTerm: string}
+` : ''}
 
 Before taking any action, follow these steps:
 
@@ -93,6 +102,15 @@ Your capabilities include:
    - Can add, retrieve, and clear memories
    - Use memory for context persistence
 
+4. Clipboard Access:
+    - Can read content from the system clipboard
+${isJinaAvailable() ? `
+5. Jina API Integration:
+    - Can read and parse content from a URL
+    - Can search content using Jina Search API
+    - Can search with grounding using Jina Grounding API
+` : ''}
+
 Always present your solution in this order:
 1. Understanding of the request
 2. Step-by-step plan
@@ -101,7 +119,7 @@ Always present your solution in this order:
 export const API_CONFIG = {
     MODEL: "claude-3-5-sonnet-20241022",
     INTENT_MODEL: "claude-3-5-haiku-20241022",
-    MAX_TOKENS: 4096,
+    MAX_TOKENS: 8192,
     MAX_INTENT_TOKENS: 20,
 }
 
@@ -150,12 +168,66 @@ export const CLIPBOARD_TOOLS: Anthropic.Beta.BetaTool[] = [
     }
 ]
 
+export const JINA_TOOLS: Anthropic.Beta.BetaTool[] = [
+    {
+        type: "custom",
+        name: "readPage",
+        description: "Read and parse content from a URL using Jina Reader API",
+        input_schema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "The URL to read and parse",
+                },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        type: "custom",
+        name: "search",
+        description: "Search content using Jina Search API",
+        input_schema: {
+            type: "object",
+            properties: {
+                searchTerm: {
+                    type: "string",
+                    description: "The term to search for",
+                },
+            },
+            required: ["searchTerm"],
+        },
+    },
+    {
+        type: "custom",
+        name: "searchGrounding",
+        description: "Search with grounding using Jina Grounding API",
+        input_schema: {
+            type: "object",
+            properties: {
+                searchTerm: {
+                    type: "string",
+                    description: "The term to search for with grounding",
+                },
+            },
+            required: ["searchTerm"],
+        },
+    },
+]
+
+export const ALL_TOOLS = [
+    ...MEMORY_TOOLS,
+    ...CLIPBOARD_TOOLS,
+    ...(isJinaAvailable() ? JINA_TOOLS : []),
+]
+
 export function getSystemContext(basePrompt: string): string {
     const settings = loadUserSettings()
     const customCommandsContext = settings.customCommands.length > 0
-        ? "\nCustom Commands:\n" + settings.customCommands
+        ? "\nAvailable Commands:\n" + settings.customCommands
             .map(cmd => `- ${cmd.name}: ${cmd.description}${cmd.helpCommand ? `\n  Help: ${cmd.helpCommand}` : ''
-                }${cmd.helpFlags ? `\n  Flags: ${cmd.helpFlags.join(', ')}` : ''
+                }${cmd.helpText ? `\n  Flags: ${cmd.helpText}` : ''
                 }`).join('\n')
         : ''
 
diff --git a/src/config/settings.ts b/src/config/settings.ts
@@ -4,7 +4,8 @@ import {UserSettings} from "../types/interfaces.ts"
 
 const DEFAULT_SETTINGS: UserSettings = {
     userName: "User",
-    customCommands: []
+    customCommands: [],
+    jinaApiKey: undefined
 }
 
 const SETTINGS_PATH = join(homedir(), ".ComputerUseAgent", "settings.json")
@@ -21,3 +22,13 @@ export function loadUserSettings(): UserSettings {
 export function saveUserSettings(settings: UserSettings) {
     Deno.writeTextFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2))
 }
+
+export function isJinaAvailable(): boolean {
+    const settings = loadUserSettings();
+    return Boolean(settings.jinaApiKey);
+}
+
+export function getJinaApiKey(): string {
+    const settings = loadUserSettings();
+    return settings.jinaApiKey || "";
+}
diff --git a/src/modules/bash/handlers.ts b/src/modules/bash/handlers.ts
@@ -32,39 +32,60 @@ export class BashHandlers {
                 return {content: "in mock mode, command did not run"}
             }
 
-            log.info(`Executing bash command: ${command}`)
 
             const shell = Deno.env.get("SHELL") || "bash"
-            const process = new Deno.Command(shell, {
-                args: ["-c", command],
-                env: this.environment,
-                stdout: "piped",
-                stderr: "piped",
-            })
-            const {stdout, stderr, code} = await process.output()
+            log.info(`Executing command: ${command}`)
 
-            const output = new TextDecoder().decode(stdout).trim()
-            const errorOutput = new TextDecoder().decode(stderr).trim()
+            try {
+                // First attempt: Try running the command directly
+                const directProcess = new Deno.Command(command.split(" ")[0], {
+                    args: command.split(" ").slice(1),
+                    env: this.environment,
+                    stdout: "piped",
+                    stderr: "piped",
+                })
+                const result = await directProcess.output()
 
-            if (code === 0) {
-                if (output) {
-                    log.info(
-                        `Command output:\n\n\`\`\`output for '${command.slice(0, 20)
-                        }...'\n${output}\n\`\`\``,
-                    )
+                const output = new TextDecoder().decode(result.stdout).trim()
+                if (result.code === 0) {
+                    if (output) {
+                        log.info(`Command output:\n\n\`\`\`output for '${command.slice(0, 20)}...'\n${output}\n\`\`\``)
+                    }
+                    return {content: output}
+                } else {
+                    const errorMessage = new TextDecoder().decode(result.stderr).trim()
+                    log.error({errorMessage})
+                    throw new Error(errorMessage)
                 }
-            } else if (errorOutput) {
-                log.error(
-                    `Command error output:\n\n\`\`\`error for '${command}'\n${errorOutput}\n\`\`\``,
-                )
-            }
+            } catch (error) {
+                log.info(`Direct execution failed, trying with shell: ${shell} -c ${command}`)
 
-            if (code !== 0) {
-                const errorMessage = errorOutput || "Command execution failed."
-                return {error: errorMessage}
-            }
+                try {
+                    // Second attempt: Try with shell -c
+                    const shellProcess = new Deno.Command(shell, {
+                        args: ["-c", command],
+                        env: this.environment,
+                        stdout: "piped",
+                        stderr: "piped",
+                    })
+                    const {stdout, stderr, code} = await shellProcess.output()
+
+                    const output = new TextDecoder().decode(stdout).trim()
+                    const errorOutput = new TextDecoder().decode(stderr).trim()
 
-            return {content: output}
+                    if (code === 0) {
+                        if (output) {
+                            log.info(`Command output:\n\n\`\`\`output for '${command.slice(0, 20)}...'\n${output}\n\`\`\``)
+                        }
+                        return {content: output}
+                    } else {
+                        log.error(`Command error output:\n\n\`\`\`error for '${command}'\n${errorOutput}\n\`\`\``)
+                        return {error: errorOutput || "Command execution failed."}
+                    }
+                } catch (finalError) {
+                    return {error: String(finalError)}
+                }
+            }
         } catch (error) {
             log.error(`Error in handleBashCommand: ${error}`)
             return {error: String(error)}
diff --git a/src/modules/hybrid/hybrid_session.ts b/src/modules/hybrid/hybrid_session.ts
@@ -1,5 +1,5 @@
 import {BaseSession} from "../../utils/session.ts"
-import {COMBINED_SYSTEM_PROMPT, API_CONFIG, MEMORY_TOOLS, CLIPBOARD_TOOLS} from "../../config/constants.ts"
+import {COMBINED_SYSTEM_PROMPT, API_CONFIG, MEMORY_TOOLS, CLIPBOARD_TOOLS, JINA_TOOLS} from "../../config/constants.ts"
 import {log} from "../../config/logging.ts"
 import {ToolHandler} from "../../utils/tool_handler.ts"
 
@@ -41,6 +41,7 @@ export class HybridSession extends BaseSession {
                         {type: "text_editor_20241022", name: "str_replace_editor"},
                         ...MEMORY_TOOLS,
                         ...CLIPBOARD_TOOLS,
+                        ...JINA_TOOLS
                     ],
                     system: this.getSystemPrompt(`${COMBINED_SYSTEM_PROMPT}\nSystem Context: ${JSON.stringify(systemInfo)}`),
                     betas: ["computer-use-2024-10-22"],
diff --git a/src/types/interfaces.ts b/src/types/interfaces.ts
@@ -1,50 +1,51 @@
 export interface ToolCall {
-  type: string;
-  name: string;
-  id: string;
+  type: string
+  name: string
+  id: string
   input: {
-    command: string;
-    path: string;
-    file_text?: string;
-    old_str?: string;
-    new_str?: string;
-    insert_line?: number;
-  };
+    command: string
+    path: string
+    file_text?: string
+    old_str?: string
+    new_str?: string
+    insert_line?: number
+  }
 }
 
 export interface ToolResult {
-  tool_call_id: string;
+  tool_call_id: string
   output: {
-    type: string;
-    content: Array<{ type: string; text: string }>;
-    tool_use_id: string;
-    is_error: boolean;
-  };
+    type: string
+    content: Array<{type: string; text: string}>
+    tool_use_id: string
+    is_error: boolean
+  }
 }
 
 export interface SystemInfo {
-  os: string;
-  arch: string;
-  isWsl: boolean;
-  shell: string;
+  os: string
+  arch: string
+  isWsl: boolean
+  shell: string
 }
 
 export interface Memory {
-  id: string;
-  content: string;
-  timestamp: number;
+  id: string
+  content: string
+  timestamp: number
 }
 
 export interface MemoryFile {
-  memories: Memory[];
+  memories: Memory[]
 }
 
 export interface UserSettings {
-  userName: string;
+  userName: string
   customCommands: {
-    name: string;
-    description: string;
-    helpCommand?: string;
-    helpFlags?: string[];
-  }[];
+    name: string
+    description: string
+    helpCommand?: string
+    helpText?: string
+  }[]
+  jinaApiKey?: string
 }
diff --git a/src/utils/functions.ts b/src/utils/functions.ts
diff --git a/src/utils/jina.ts b/src/utils/jina.ts
diff --git a/src/utils/tool_handler.ts b/src/utils/tool_handler.ts
