@travisennis/acai 0.0.11 → 0.0.13

package/dist/tools/skill.js

@@ -1,6 +1,6 @@
-import { readFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { readdir, readFile } from "node:fs/promises";
 import { z } from "zod";
+import { config, parseSkillsPath } from "../config/index.js";
 import { loadSkills } from "../skills/index.js";
 import style from "../terminal/style.js";
 import { replaceArgumentPlaceholders } from "../utils/templates.js";
@@ -13,8 +13,56 @@ const inputSchema = z.object({
         .describe('The skill name. E.g., "commit", "review-pr", or "pdf"'),
     args: z.string().optional().describe("Optional arguments for the skill"),
 });
-export async function createSkillTool() {
-    const skills = await loadSkills();
+/**
+ * List resources (files and directories) in a skill directory.
+ * Returns relative paths, excluding SKILL.md and hidden files.
+ */
+async function listSkillResources(baseDir) {
+    try {
+        const entries = await readdir(baseDir, { withFileTypes: true });
+        const resources = [];
+        for (const entry of entries) {
+            // Skip SKILL.md (already included in body)
+            if (entry.name === "SKILL.md")
+                continue;
+            // Skip hidden files
+            if (entry.name.startsWith("."))
+                continue;
+            resources.push(entry.name);
+        }
+        // Sort for consistent output
+        resources.sort();
+        // Cap at 50 files to avoid overwhelming output
+        return resources.slice(0, 50);
+    }
+    catch {
+        // Directory read failed, return empty
+        return [];
+    }
+}
+/**
+ * Build the result string for a skill execution.
+ */
+function buildSkillResult(skill, body, resources, args) {
+    let result = `# Skill: ${skill.name}\n\n`;
+    result += `**Base directory**: ${skill.baseDir}\n\n`;
+    if (resources.length > 0) {
+        result += "<skill_resources>\n";
+        for (const resource of resources) {
+            result += `${resource}\n`;
+        }
+        result += "</skill_resources>\n\n";
+        result +=
+            "Relative paths in this skill are relative to the base directory.\n\n";
+    }
+    const argsArray = args ? args.split(/\s+/).filter(Boolean) : [];
+    result += replaceArgumentPlaceholders(body, argsArray);
+    return result;
+}
+export async function createSkillTool(activatedSkillsTracker) {
+    const appConfig = await config.getConfig();
+    const skillPaths = parseSkillsPath(appConfig.skills.path);
+    const skills = await loadSkills(skillPaths);
     const modelInvocableSkills = skills.getModelInvocable();
     const description = "Run a skill (e.g., commit, review-pr).";
     return {
@@ -30,35 +78,37 @@ export async function createSkillTool() {
                 if (abortSignal?.aborted) {
                     throw new Error("Skill execution aborted");
                 }
+                // Check for deduplication
+                if (activatedSkillsTracker.has(skillName)) {
+                    return `Skill "${skillName}" is already loaded in this session. Its instructions are available in the conversation context.`;
+                }
                 // Find the skill
                 const skill = modelInvocableSkills.find((s) => s.name === skillName);
                 if (!skill) {
                     const availableSkillNames = modelInvocableSkills
                         .map((s) => s.name)
                         .join(", ");
-                    const errorMsg = `Skill "${skillName}" not found. Available skills: ${availableSkillNames}`;
-                    return errorMsg;
+                    return `Skill "${skillName}" not found. Available skills: ${availableSkillNames}`;
                 }
                 if (skill.disableModelInvocation) {
                     return `Skill "${skillName}" is not available for model invocation.`;
                 }
                 // Read the skill file
                 const content = await readFile(skill.filePath, "utf8");
-                let result = `# Skill Name: ${skill.name}`;
-                result += `\n**Base directory**: ${dirname(skill.filePath)}\n\n`;
-                result +=
-                    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.\n";
                 // Parse frontmatter and body
                 const yamlStart = content.indexOf("---");
                 const yamlEnd = content.indexOf("---", yamlStart + 3);
                 const body = yamlEnd !== -1 ? content.slice(yamlEnd + 3).trim() : content;
-                const argsArray = args ? args.split(/\s+/).filter(Boolean) : [];
-                result += replaceArgumentPlaceholders(body, argsArray);
+                // List resources in skill directory
+                const resources = await listSkillResources(skill.baseDir);
+                // Build result
+                const result = buildSkillResult(skill, body, resources, args);
+                // Mark as activated
+                activatedSkillsTracker.add(skillName);
                 return result;
             }
             catch (error) {
-                const errorMsg = `${error.message}`;
-                return errorMsg;
+                return error.message;
             }
         },
     };

package/dist/tools/types.d.ts

@@ -1,20 +1,26 @@
 import { z } from "zod";
 export declare const fileEncodingSchema: z.ZodEnum<{
+    base64: "base64";
+    base64url: "base64url";
     utf8: "utf8";
     ascii: "ascii";
     "utf-8": "utf-8";
     utf16le: "utf16le";
     ucs2: "ucs2";
     "ucs-2": "ucs-2";
-    base64: "base64";
-    base64url: "base64url";
     latin1: "latin1";
     binary: "binary";
     hex: "hex";
 }>;
+export type SessionContext = {
+    sessionId: string;
+    projectDir: string;
+    agentName: string;
+};
 export type ToolExecutionOptions = {
     toolCallId: string;
     messages?: any[];
     abortSignal?: AbortSignal;
+    sessionContext?: SessionContext;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/tools/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAC;IAEnB,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAC;IAEnB,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,CAAC"}

package/dist/tools/web-fetch.d.ts

@@ -11,18 +11,14 @@ declare const inputSchema: z.ZodObject<{
     output: z.ZodDefault<z.ZodEnum<{
         markdown: "markdown";
         text: "text";
-        html: "html";
         json: "json";
+        html: "html";
     }>>;
-    jina: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-    timeout: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-    headers: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    jina: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    timeout: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+    headers: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
 }, z.core.$strip>;
 type WebFetchInputSchema = z.infer<typeof inputSchema>;
-/**
- * Execute web fetch
- */
-export declare function executeWebFetch(options: WebFetchInputSchema, executionOptions: ToolExecutionOptions): Promise<string>;
 /**
  * Create the web fetch tool
  */
@@ -34,12 +30,12 @@ export declare const createWebFetchTool: () => Promise<{
             output: z.ZodDefault<z.ZodEnum<{
                 markdown: "markdown";
                 text: "text";
-                html: "html";
                 json: "json";
+                html: "html";
             }>>;
-            jina: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
-            timeout: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-            headers: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            jina: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            timeout: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+            headers: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
         }, z.core.$strip>;
     };
     display({ url }: WebFetchInputSchema): string;

package/dist/tools/web-fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-fetch.d.ts","sourceRoot":"","sources":["../../source/tools/web-fetch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAQF;;GAEG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA6bvD;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,gBAAgB,EAAE,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC,CAiEjB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;qBAQV,mBAAmB;qBAIzB,mBAAmB,oBACV,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC;EAIrB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"web-fetch.d.ts","sourceRoot":"","sources":["../../source/tools/web-fetch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AASF;;GAEG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA+jBvD;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;qBAQV,mBAAmB;qBAIzB,mBAAmB,oBACV,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC;EAIrB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC"}

package/dist/tools/web-fetch.js

@@ -1,3 +1,6 @@
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { load } from "cheerio";
 import { z } from "zod";
 import style from "../terminal/style.js";
@@ -9,6 +12,7 @@ const DEFAULT_TIMEOUT = 30000; // 30 seconds
 const MAX_REDIRECTS = 5;
 const MAX_URL_LENGTH = 2048;
 const JINA_API_BASE = "https://r.jina.ai";
+const MAX_INLINE_SIZE = 50_000; // bytes; content exceeding this is written to a temp file
 /**
  * Input schema for the web fetch tool
  */
@@ -297,6 +301,51 @@ async function handleTextResponse(response, contentType) {
         provider: "direct",
     };
 }
+/**
+ * If the response is a redirect (3xx with a Location header), return the
+ * resolved redirect target URL. Otherwise returns null.
+ */
+function getRedirectUrl(response, currentUrl) {
+    if (response.status < 300 || response.status >= 400) {
+        return null;
+    }
+    const location = response.headers.get("location");
+    if (!location) {
+        return null;
+    }
+    return new URL(location, currentUrl).toString();
+}
+/**
+ * Process a non-redirect fetch response: validate status, determine content
+ * type, and delegate to the appropriate handler.
+ */
+async function processNonRedirectResponse(response, options) {
+    const { useJina, includeHeaders, signal, verbose } = options;
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status} ${response.statusText}`);
+    }
+    const contentType = getContentType(response);
+    const responseHeaders = {};
+    if (includeHeaders) {
+        response.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
+        });
+    }
+    let result;
+    if (contentType.includes("text/html")) {
+        result = await handleHtmlResponse(response, useJina, signal, verbose);
+    }
+    else if (contentType.startsWith("image/")) {
+        result = await handleImageResponse(response, contentType);
+    }
+    else {
+        result = await handleTextResponse(response, contentType);
+    }
+    if (includeHeaders) {
+        result.headers = responseHeaders;
+    }
+    return result;
+}
 /**
  * Main fetch function with redirect handling
  */
@@ -328,43 +377,21 @@ async function fetchUrl(url, options) {
                 redirect: "manual",
                 headers: requestHeaders,
             });
-            // Handle redirects
-            if (response.status >= 300 && response.status < 400) {
-                const location = response.headers.get("location");
-                if (location) {
-                    const redirectUrl = new URL(location, currentUrl).toString();
-                    if (verbose) {
-                        console.error(`Redirecting to: ${redirectUrl}`);
-                    }
-                    currentUrl = redirectUrl;
-                    redirectCount++;
-                    continue;
+            const redirectUrl = getRedirectUrl(response, currentUrl);
+            if (redirectUrl) {
+                if (verbose) {
+                    console.error(`Redirecting to: ${redirectUrl}`);
                 }
+                currentUrl = redirectUrl;
+                redirectCount++;
+                continue;
             }
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status} ${response.statusText}`);
-            }
-            const contentType = getContentType(response);
-            const responseHeaders = {};
-            if (includeHeaders) {
-                response.headers.forEach((value, key) => {
-                    responseHeaders[key] = value;
-                });
-            }
-            let result;
-            if (contentType.includes("text/html")) {
-                result = await handleHtmlResponse(response, useJina, signal, verbose);
-            }
-            else if (contentType.startsWith("image/")) {
-                result = await handleImageResponse(response, contentType);
-            }
-            else {
-                result = await handleTextResponse(response, contentType);
-            }
-            if (includeHeaders) {
-                result.headers = responseHeaders;
-            }
-            return result;
+            return await processNonRedirectResponse(response, {
+                useJina,
+                includeHeaders,
+                signal,
+                verbose,
+            });
         }
         finally {
             cleanup();
@@ -375,7 +402,7 @@ async function fetchUrl(url, options) {
 /**
  * Execute web fetch
  */
-export async function executeWebFetch(options, executionOptions) {
+async function executeWebFetch(options, executionOptions) {
     const { url, output = "text", jina = false, timeout, headers = false, } = options;
     if (executionOptions.abortSignal?.aborted) {
         throw new Error("Web fetch aborted");
@@ -400,6 +427,7 @@ export async function executeWebFetch(options, executionOptions) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         throw new Error(`Web fetch failed: ${errorMessage}`);
     }
+    let content;
     switch (output) {
         case "json": {
             const jsonOutput = {
@@ -413,18 +441,32 @@ export async function executeWebFetch(options, executionOptions) {
             if (headers && result.headers) {
                 jsonOutput["headers"] = result["headers"];
             }
-            return JSON.stringify(jsonOutput, null, 2);
+            content = JSON.stringify(jsonOutput, null, 2);
+            break;
         }
         case "html":
-            return result.content;
+            content = result.content;
+            break;
         case "markdown":
-            if (result.contentType.includes("text/html")) {
-                return htmlToMarkdown(result.content);
-            }
-            return result.content;
+            content = result.contentType.includes("text/html")
+                ? htmlToMarkdown(result.content)
+                : result.content;
+            break;
         default:
-            return result.content;
+            content = result.content;
+            break;
+    }
+    const contentSize = Buffer.byteLength(content, "utf-8");
+    if (contentSize > MAX_INLINE_SIZE) {
+        const tmpFile = join(tmpdir(), `acai-webfetch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.txt`);
+        writeFileSync(tmpFile, content, "utf-8");
+        return [
+            `The fetched content from ${url} is ${contentSize} bytes which exceeds the ${MAX_INLINE_SIZE} byte inline limit.`,
+            `The full content has been saved to: ${tmpFile}`,
+            "To use this content, read the file in parts using the Read tool or search it with the Grep tool.",
+        ].join("\n");
     }
+    return content;
 }
 /**
  * Create the web fetch tool
@@ -437,7 +479,7 @@ export const createWebFetchTool = async () => {
             inputSchema,
         },
         display({ url }) {
-            return `🌐 ${style.cyan(url)}`;
+            return `${style.cyan(url)}`;
         },
         async execute(options, executionOptions) {
             return executeWebFetch(options, executionOptions);

package/dist/tools/web-search.d.ts

@@ -8,18 +8,14 @@ export declare const WebSearchTool: {
  */
 declare const inputSchema: z.ZodObject<{
     query: z.ZodString;
-    numResults: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-    timeout: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+    numResults: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+    timeout: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
     provider: z.ZodOptional<z.ZodEnum<{
         exa: "exa";
         duckduckgo: "duckduckgo";
     }>>;
 }, z.core.$strip>;
 type WebSearchInputSchema = z.infer<typeof inputSchema>;
-/**
- * Execute web search
- */
-export declare function executeWebSearch(options: WebSearchInputSchema, executionOptions: ToolExecutionOptions): Promise<string>;
 /**
  * Create the web search tool
  */
@@ -28,8 +24,8 @@ export declare const createWebSearchTool: () => Promise<{
         description: string;
         inputSchema: z.ZodObject<{
             query: z.ZodString;
-            numResults: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
-            timeout: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+            numResults: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+            timeout: z.ZodOptional<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
             provider: z.ZodOptional<z.ZodEnum<{
                 exa: "exa";
                 duckduckgo: "duckduckgo";

package/dist/tools/web-search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-search.d.ts","sourceRoot":"","sources":["../../source/tools/web-search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,aAAa;;CAEzB,CAAC;AAQF;;GAEG;AACH,QAAA,MAAM,WAAW;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA+MxD;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,oBAAoB,EAC7B,gBAAgB,EAAE,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC,CAwEjB;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;uBAQT,oBAAoB;qBAI5B,oBAAoB,oBACX,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC;EAIrB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"web-search.d.ts","sourceRoot":"","sources":["../../source/tools/web-search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,aAAa;;CAEzB,CAAC;AAQF;;GAEG;AACH,QAAA,MAAM,WAAW;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA6SxD;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;uBAQT,oBAAoB;qBAI5B,oBAAoB,oBACX,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC;EAIrB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC"}

package/dist/tools/web-search.js

@@ -151,10 +151,45 @@ async function fetchDuckDuckGo(query, numResults, signal) {
         totalResults: data.RelatedTopics.length,
     };
 }
+/**
+ * Attempt Exa search with automatic fallback to DuckDuckGo
+ */
+async function fetchExaWithFallback(query, numResults, signal) {
+    try {
+        return await fetchExa(query, numResults, signal);
+    }
+    catch (error) {
+        // If aborted, re-throw the original error
+        if (signal.aborted) {
+            throw error;
+        }
+        // Provide more helpful error message about network failures
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("fetch failed") ||
+            errorMessage.includes("ENOTFOUND") ||
+            errorMessage.includes("connect")) {
+            throw new Error(`Exa API is not accessible (network error). Try using provider="duckduckgo" instead.`);
+        }
+        // For non-network errors (auth, rate limit, etc.), fall back to DuckDuckGo
+        return await fetchDuckDuckGo(query, numResults, signal);
+    }
+}
+/**
+ * Format search response into a human-readable string
+ */
+function formatSearchResults(query, response) {
+    if (response.results.length === 0) {
+        return `No search results found for "${query}".`;
+    }
+    const resultsText = response.results
+        .map((result, index) => `${index + 1}. [${result.title}](${result.url})\n   ${result.snippet.substring(0, 200)}${result.snippet.length > 200 ? "..." : ""}`)
+        .join("\n\n");
+    return `Search results for "${query}" (${response.provider}):\n\n${resultsText}\n\nTotal results: ${response.totalResults || response.results.length}`;
+}
 /**
  * Execute web search
  */
-export async function executeWebSearch(options, executionOptions) {
+async function executeWebSearch(options, executionOptions) {
     const { query, numResults = DEFAULT_NUM_RESULTS, timeout = DEFAULT_TIMEOUT, provider = "exa", } = options;
     if (executionOptions.abortSignal?.aborted) {
         throw new Error("Web search aborted");
@@ -166,37 +201,10 @@ export async function executeWebSearch(options, executionOptions) {
     const effectiveTimeout = Math.min(Math.max(timeout ?? 1000, 1000), 60000);
     const { signal, cleanup } = createTimeoutSignal(effectiveTimeout, executionOptions.abortSignal);
     try {
-        let response;
-        if (provider === "duckduckgo") {
-            response = await fetchDuckDuckGo(query, effectiveNumResults, signal);
-        }
-        else {
-            // Try Exa first, fall back to DuckDuckGo
-            try {
-                response = await fetchExa(query, effectiveNumResults, signal);
-            }
-            catch (exaError) {
-                // Fall back to DuckDuckGo if Exa fails (but not if aborted)
-                if (signal.aborted) {
-                    throw exaError;
-                }
-                // Provide more helpful error message about Exa failure
-                const errorMsg = exaError instanceof Error ? exaError.message : String(exaError);
-                if (errorMsg.includes("fetch failed") ||
-                    errorMsg.includes("ENOTFOUND") ||
-                    errorMsg.includes("connect")) {
-                    throw new Error(`Exa API is not accessible (network error). Try using provider="duckduckgo" instead.`);
-                }
-                response = await fetchDuckDuckGo(query, effectiveNumResults, signal);
-            }
-        }
-        if (response.results.length === 0) {
-            return `No search results found for "${query}".`;
-        }
-        const resultsText = response.results
-            .map((result, index) => `${index + 1}. [${result.title}](${result.url})\n   ${result.snippet.substring(0, 200)}${result.snippet.length > 200 ? "..." : ""}`)
-            .join("\n\n");
-        return `Search results for "${query}" (${response.provider}):\n\n${resultsText}\n\nTotal results: ${response.totalResults || response.results.length}`;
+        const response = provider === "duckduckgo"
+            ? await fetchDuckDuckGo(query, effectiveNumResults, signal)
+            : await fetchExaWithFallback(query, effectiveNumResults, signal);
+        return formatSearchResults(query, response);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -217,7 +225,7 @@ export const createWebSearchTool = async () => {
             inputSchema,
         },
         display({ query }) {
-            return `🔍 ${style.cyan(query)}`;
+            return `${style.cyan(query)}`;
         },
         async execute(options, executionOptions) {
             return executeWebSearch(options, executionOptions);

package/dist/tui/autocomplete/utils.d.ts

@@ -1,17 +1,2 @@
-import type { Dirent } from "node:fs";
-export declare class DirectoryCache {
-    private cache;
-    private ttl;
-    get(dir: string): Promise<Dirent[] | null>;
-    set(dir: string, entries: Dirent[]): void;
-    clear(): void;
-}
-export declare const directoryCache: DirectoryCache;
-interface DirentWithPath extends Dirent {
-    parentPath: string;
-}
-export declare function getDirectoryEntries(dirs: string[]): Promise<DirentWithPath[]>;
-export declare function isPathWithinAllowedDirs(requestedPath: string, allowedDirs: string[]): Promise<boolean>;
 export declare function extractPathPrefix(text: string, forceExtract?: boolean): string | null;
-export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/tui/autocomplete/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/tui/autocomplete/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAKtC,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAA+D;IAC5E,OAAO,CAAC,GAAG,CAAQ;IAEb,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC;IAQhD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAIzC,KAAK,IAAI,IAAI;CAGd;AAED,eAAO,MAAM,cAAc,gBAAuB,CAAC;AAGnD,UAAU,cAAe,SAAQ,MAAM;IACrC,UAAU,EAAE,MAAM,CAAC;CACpB;AAGD,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,cAAc,EAAE,CAAC,CA4B3B;AA8BD,wBAAsB,uBAAuB,CAC3C,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,OAAO,CAAC,CAWlB;AAmCD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,YAAY,UAAQ,GACnB,MAAM,GAAG,IAAI,CAuCf"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../source/tui/autocomplete/utils.ts"],"names":[],"mappings":"AAiCA,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,YAAY,UAAQ,GACnB,MAAM,GAAG,IAAI,CAuCf"}

package/dist/tui/autocomplete/utils.js

@@ -1,88 +1,3 @@
-import { readdir, realpath } from "node:fs/promises";
-import { isAbsolute, relative, resolve } from "node:path";
-// Cache for directory listings to improve performance
-export class DirectoryCache {
-    cache = new Map();
-    ttl = 3000; // 3 seconds
-    async get(dir) {
-        const cached = this.cache.get(dir);
-        if (cached && Date.now() - cached.timestamp < this.ttl) {
-            return cached.entries;
-        }
-        return null;
-    }
-    set(dir, entries) {
-        this.cache.set(dir, { entries, timestamp: Date.now() });
-    }
-    clear() {
-        this.cache.clear();
-    }
-}
-export const directoryCache = new DirectoryCache();
-// Helper function to get directory entries with caching and timeout
-export async function getDirectoryEntries(dirs) {
-    const results = [];
-    for (const dir of dirs) {
-        const cached = await directoryCache.get(dir);
-        if (cached) {
-            for (const entry of cached) {
-                results.push(Object.assign(entry, { parentPath: dir }));
-            }
-            continue;
-        }
-        try {
-            // Add timeout to prevent hanging on slow file systems
-            const entries = await Promise.race([
-                readdir(dir, { withFileTypes: true }),
-                new Promise((_, reject) => setTimeout(() => reject(new Error("Directory read timeout")), 2000)),
-            ]);
-            directoryCache.set(dir, entries);
-            for (const entry of entries) {
-                results.push(Object.assign(entry, { parentPath: dir }));
-            }
-        }
-        catch (_e) {
-            // ignore
-        }
-    }
-    return results;
-}
-// Cache for resolved allowed directories to avoid repeated realpath calls
-const resolvedAllowedDirsCache = new Map();
-async function getResolvedPath(path) {
-    const cached = resolvedAllowedDirsCache.get(path);
-    if (cached !== undefined) {
-        return cached;
-    }
-    const absPath = resolve(path);
-    let resolved = absPath;
-    try {
-        resolved = await realpath(absPath);
-    }
-    catch {
-        // If path doesn't exist, use the resolved absolute path
-    }
-    // Cache with a size limit
-    if (resolvedAllowedDirsCache.size > 500) {
-        const firstKey = resolvedAllowedDirsCache.keys().next().value;
-        if (firstKey !== undefined) {
-            resolvedAllowedDirsCache.delete(firstKey);
-        }
-    }
-    resolvedAllowedDirsCache.set(path, resolved);
-    return resolved;
-}
-export async function isPathWithinAllowedDirs(requestedPath, allowedDirs) {
-    const target = await getResolvedPath(requestedPath);
-    for (const allowedDir of allowedDirs) {
-        const absAllowed = await getResolvedPath(allowedDir);
-        const rel = relative(absAllowed, target);
-        if (rel === "" || (!rel.startsWith("..") && !isAbsolute(rel))) {
-            return true;
-        }
-    }
-    return false;
-}
 function hasPathIndicator(pathPrefix) {
     return (pathPrefix.includes("/") ||
         pathPrefix.endsWith("/") ||

package/dist/tui/autocomplete.d.ts

@@ -8,6 +8,6 @@ export type { SlashCommand } from "./autocomplete/command-provider.ts";
 export { CommandProvider } from "./autocomplete/command-provider.ts";
 export { FileSearchProvider } from "./autocomplete/file-search-provider.ts";
 export { SkillProvider } from "./autocomplete/skill-provider.ts";
-export { DirectoryCache, directoryCache, extractPathPrefix, getDirectoryEntries, isPathWithinAllowedDirs, } from "./autocomplete/utils.ts";
+export { extractPathPrefix } from "./autocomplete/utils.ts";
 export declare function createDefaultProvider<T extends SlashCommand | AutocompleteItem>(commands?: T[], _allowedDirs?: string[]): CombinedProvider;
 //# sourceMappingURL=autocomplete.d.ts.map

package/dist/tui/autocomplete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../source/tui/autocomplete.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,YAAY,EACV,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,YAAY,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EACL,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,yBAAyB,CAAC;AAGjC,wBAAgB,qBAAqB,CACnC,CAAC,SAAS,YAAY,GAAG,gBAAgB,EACzC,QAAQ,GAAE,CAAC,EAAO,EAAE,YAAY,GAAE,MAAM,EAAoB,oBAM7D"}
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../source/tui/autocomplete.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,YAAY,EACV,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,YAAY,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5D,wBAAgB,qBAAqB,CACnC,CAAC,SAAS,YAAY,GAAG,gBAAgB,EACzC,QAAQ,GAAE,CAAC,EAAO,EAAE,YAAY,GAAE,MAAM,EAAoB,oBAM7D"}