awel 0.1.0

package/dist/cli/tools/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Returns all agentic tools configured for the given project directory.
+ * Tool names use PascalCase to match Claude Code tool names for consistent SSE events.
+ */
+export declare function awelTools(cwd: string): {
+    Read: import("ai").Tool<{
+        file_path: string;
+    }, string>;
+    Write: import("ai").Tool<{
+        file_path: string;
+        content: string;
+    }, string>;
+    Edit: import("ai").Tool<{
+        file_path: string;
+        old_string: string;
+        new_string: string;
+        replace_all: boolean;
+    }, string>;
+    MultiEdit: import("ai").Tool<{
+        file_path: string;
+        edits: {
+            old_string: string;
+            new_string: string;
+            replace_all: boolean;
+        }[];
+    }, string>;
+    Bash: import("ai").Tool<{
+        command: string;
+        timeout: number;
+    }, string>;
+    Glob: import("ai").Tool<{
+        pattern: string;
+        path?: string | undefined;
+    }, string>;
+    Grep: import("ai").Tool<{
+        pattern: string;
+        path?: string | undefined;
+        include?: string | undefined;
+    }, string>;
+    Ls: import("ai").Tool<{
+        path: string;
+    }, string>;
+    ProposePlan: import("ai").Tool<{
+        title: string;
+        content: string;
+    }, string>;
+    AskUser: import("ai").Tool<{
+        questions: {
+            question: string;
+            header: string;
+            multiSelect: boolean;
+            options: {
+                label: string;
+                description: string;
+            }[];
+        }[];
+    }, string>;
+    ReactBestPractices: import("ai").Tool<{
+        section: "waterfalls" | "bundle" | "server" | "client" | "rerender" | "rendering" | "javascript" | "advanced" | "all";
+    }, string>;
+    WebSearch: import("ai").Tool<{
+        query: string;
+        numResults: number;
+        type: "auto" | "fast" | "deep";
+    }, string>;
+    WebFetch: import("ai").Tool<{
+        url: string;
+        format: "text" | "markdown" | "html";
+        timeout?: number | undefined;
+    }, string>;
+    CodeSearch: import("ai").Tool<{
+        query: string;
+        tokensNum: number;
+    }, string>;
+    TodoRead: import("ai").Tool<Record<string, never>, string>;
+    TodoWrite: import("ai").Tool<{
+        todos: {
+            content: string;
+            status: "pending" | "in_progress" | "completed";
+            id?: number | undefined;
+        }[];
+    }, string>;
+    RestartDevServer: import("ai").Tool<{
+        reason?: string | undefined;
+    }, string>;
+};

package/dist/cli/tools/index.js

@@ -0,0 +1,41 @@
+import { createReadTool } from './read.js';
+import { createWriteTool } from './write.js';
+import { createEditTool } from './edit.js';
+import { createBashTool } from './bash.js';
+import { createGlobTool } from './glob.js';
+import { createLsTool } from './ls.js';
+import { createProposePlanTool } from './propose-plan.js';
+import { createAskUserTool } from './ask-user.js';
+import { createReactBestPracticesTool } from './react-best-practices.js';
+import { createWebSearchTool } from './web-search.js';
+import { createWebFetchTool } from './web-fetch.js';
+import { createGrepTool } from './grep.js';
+import { createCodeSearchTool } from './code-search.js';
+import { createMultiEditTool } from './multi-edit.js';
+import { createTodoReadTool, createTodoWriteTool } from './todo.js';
+import { createRestartDevServerTool } from './restart-dev-server.js';
+/**
+ * Returns all agentic tools configured for the given project directory.
+ * Tool names use PascalCase to match Claude Code tool names for consistent SSE events.
+ */
+export function awelTools(cwd) {
+    return {
+        Read: createReadTool(cwd),
+        Write: createWriteTool(cwd),
+        Edit: createEditTool(cwd),
+        MultiEdit: createMultiEditTool(cwd),
+        Bash: createBashTool(cwd),
+        Glob: createGlobTool(cwd),
+        Grep: createGrepTool(cwd),
+        Ls: createLsTool(cwd),
+        ProposePlan: createProposePlanTool(),
+        AskUser: createAskUserTool(),
+        ReactBestPractices: createReactBestPracticesTool(),
+        WebSearch: createWebSearchTool(),
+        WebFetch: createWebFetchTool(),
+        CodeSearch: createCodeSearchTool(),
+        TodoRead: createTodoReadTool(),
+        TodoWrite: createTodoWriteTool(),
+        RestartDevServer: createRestartDevServerTool(),
+    };
+}

package/dist/cli/tools/ls.d.ts

@@ -0,0 +1,3 @@
+export declare function createLsTool(cwd: string): import("ai").Tool<{
+    path: string;
+}, string>;

package/dist/cli/tools/ls.js

@@ -0,0 +1,31 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { readdirSync, statSync } from 'fs';
+import { resolve, join } from 'path';
+export function createLsTool(cwd) {
+    return tool({
+        description: 'List the contents of a directory. Returns file and directory names with type indicators.',
+        inputSchema: z.object({
+            path: z.string().optional().default('.').describe('Directory path to list (default: project root)'),
+        }),
+        execute: async ({ path }) => {
+            const fullPath = path.startsWith('/') ? path : resolve(cwd, path);
+            try {
+                const entries = readdirSync(fullPath);
+                const results = entries.map(name => {
+                    try {
+                        const stat = statSync(join(fullPath, name));
+                        return stat.isDirectory() ? `${name}/` : name;
+                    }
+                    catch {
+                        return name;
+                    }
+                });
+                return results.join('\n') || '(empty directory)';
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+}

package/dist/cli/tools/multi-edit.d.ts

@@ -0,0 +1,8 @@
+export declare function createMultiEditTool(cwd: string): import("ai").Tool<{
+    file_path: string;
+    edits: {
+        old_string: string;
+        new_string: string;
+        replace_all: boolean;
+    }[];
+}, string>;

package/dist/cli/tools/multi-edit.js

@@ -0,0 +1,53 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { pushSnapshot } from '../undo.js';
+export function createMultiEditTool(cwd) {
+    return tool({
+        description: 'Perform multiple find-and-replace edits on a single file in one operation. ' +
+            'Edits are applied sequentially — each edit sees the result of previous ones. ' +
+            'Use this instead of multiple Edit calls when making several changes to the same file.',
+        inputSchema: z.object({
+            file_path: z.string().describe('Path to the file to edit (absolute or relative to project root)'),
+            edits: z.array(z.object({
+                old_string: z.string().describe('The exact string to find'),
+                new_string: z.string().describe('The replacement string'),
+                replace_all: z.boolean().optional().default(false).describe('Replace all occurrences'),
+            })).min(1).describe('List of edits to apply sequentially'),
+        }),
+        execute: async ({ file_path, edits }) => {
+            const fullPath = file_path.startsWith('/') ? file_path : resolve(cwd, file_path);
+            if (!existsSync(fullPath)) {
+                return `Error: File not found: ${fullPath}`;
+            }
+            try {
+                pushSnapshot(fullPath);
+                let content = readFileSync(fullPath, 'utf-8');
+                const results = [];
+                for (let i = 0; i < edits.length; i++) {
+                    const { old_string, new_string, replace_all } = edits[i];
+                    if (!content.includes(old_string)) {
+                        results.push(`Edit ${i + 1}: old_string not found`);
+                        continue;
+                    }
+                    content = replace_all
+                        ? content.replaceAll(old_string, new_string)
+                        : content.replace(old_string, new_string);
+                    results.push(`Edit ${i + 1}: applied`);
+                }
+                writeFileSync(fullPath, content, 'utf-8');
+                const applied = results.filter(r => r.endsWith('applied')).length;
+                const failed = results.filter(r => r.endsWith('not found')).length;
+                let summary = `Applied ${applied}/${edits.length} edits to ${file_path}`;
+                if (failed > 0) {
+                    summary += `\n${results.filter(r => r.endsWith('not found')).join('\n')}`;
+                }
+                return summary;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+}

package/dist/cli/tools/propose-plan.d.ts

@@ -0,0 +1,4 @@
+export declare function createProposePlanTool(): import("ai").Tool<{
+    title: string;
+    content: string;
+}, string>;

package/dist/cli/tools/propose-plan.js

@@ -0,0 +1,21 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export function createProposePlanTool() {
+    return tool({
+        description: 'Propose a structured implementation plan before executing a complex task. ' +
+            'Use this tool when the user\'s request involves changes to 2 or more files, ' +
+            'or any non-trivial multi-step work. The content should be a detailed markdown plan ' +
+            '(up to 600-700 words for complex projects) covering an overview, step-by-step ' +
+            'implementation details, files to modify/create, and critical considerations. ' +
+            'After proposing a plan, STOP and wait for the user to approve or provide feedback.',
+        inputSchema: z.object({
+            title: z.string().describe('A concise title for the plan'),
+            content: z.string().describe('The full markdown plan content'),
+        }),
+        execute: async (input) => {
+            // The actual interception happens in the streaming loop (vercel.ts).
+            // This execute just returns the input so the tool call completes.
+            return JSON.stringify(input);
+        },
+    });
+}

package/dist/cli/tools/react-best-practices.d.ts

@@ -0,0 +1,3 @@
+export declare function createReactBestPracticesTool(): import("ai").Tool<{
+    section: "waterfalls" | "bundle" | "server" | "client" | "rerender" | "rendering" | "javascript" | "advanced" | "all";
+}, string>;

package/dist/cli/tools/react-best-practices.js

@@ -0,0 +1,55 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const skillPath = resolve(__dirname, '..', 'skills', 'react-best-practices.md');
+let cached = null;
+function loadSkill() {
+    if (!cached) {
+        cached = readFileSync(skillPath, 'utf-8');
+    }
+    return cached;
+}
+const SECTIONS = {
+    waterfalls: '## 1. Eliminating Waterfalls',
+    bundle: '## 2. Bundle Size Optimization',
+    server: '## 3. Server-Side Performance',
+    client: '## 4. Client-Side Data Fetching',
+    rerender: '## 5. Re-render Optimization',
+    rendering: '## 6. Rendering Performance',
+    javascript: '## 7. JavaScript Performance',
+    advanced: '## 8. Advanced Patterns',
+};
+export function createReactBestPracticesTool() {
+    return tool({
+        description: 'Get React and Next.js performance best practices (40+ rules across 8 categories). ' +
+            'Call with no section to get the full guide, or specify a section to get just that category. ' +
+            'Sections: waterfalls, bundle, server, client, rerender, rendering, javascript, advanced.',
+        inputSchema: z.object({
+            section: z
+                .enum(['all', 'waterfalls', 'bundle', 'server', 'client', 'rerender', 'rendering', 'javascript', 'advanced'])
+                .optional()
+                .default('all')
+                .describe('Which section to return. Defaults to "all" for the full guide.'),
+        }),
+        execute: async ({ section }) => {
+            const content = loadSkill();
+            if (section === 'all') {
+                return content;
+            }
+            const heading = SECTIONS[section];
+            if (!heading) {
+                return `Unknown section: ${section}. Available: ${Object.keys(SECTIONS).join(', ')}`;
+            }
+            const start = content.indexOf(heading);
+            if (start === -1) {
+                return `Section "${section}" not found in the guide.`;
+            }
+            // Find the next section heading (## N.) or end of file
+            const nextSection = content.indexOf('\n## ', start + heading.length);
+            return nextSection === -1 ? content.slice(start) : content.slice(start, nextSection);
+        },
+    });
+}

package/dist/cli/tools/read.d.ts

@@ -0,0 +1,3 @@
+export declare function createReadTool(cwd: string): import("ai").Tool<{
+    file_path: string;
+}, string>;

package/dist/cli/tools/read.js

@@ -0,0 +1,24 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+export function createReadTool(cwd) {
+    return tool({
+        description: 'Read the contents of a file at the given path. Returns the file content as a string.',
+        inputSchema: z.object({
+            file_path: z.string().describe('The path to the file to read (absolute or relative to project root)'),
+        }),
+        execute: async ({ file_path }) => {
+            const fullPath = file_path.startsWith('/') ? file_path : resolve(cwd, file_path);
+            if (!existsSync(fullPath)) {
+                return `Error: File not found: ${fullPath}`;
+            }
+            try {
+                return readFileSync(fullPath, 'utf-8');
+            }
+            catch (err) {
+                return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+}

package/dist/cli/tools/restart-dev-server.d.ts

@@ -0,0 +1,3 @@
+export declare function createRestartDevServerTool(): import("ai").Tool<{
+    reason?: string | undefined;
+}, string>;

package/dist/cli/tools/restart-dev-server.js

@@ -0,0 +1,18 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { restartDevServer } from '../subprocess.js';
+export function createRestartDevServerTool() {
+    return tool({
+        description: 'Restart the user\'s dev server (Next.js). Use when the dev server has crashed, is unresponsive, or needs a restart after config changes.',
+        inputSchema: z.object({
+            reason: z.string().optional().describe('Why the restart is needed (for logging)'),
+        }),
+        execute: async ({ reason }) => {
+            if (reason) {
+                console.error(`[awel] RestartDevServer: ${reason}`);
+            }
+            const result = await restartDevServer();
+            return result.message;
+        },
+    });
+}

package/dist/cli/tools/todo.d.ts

@@ -0,0 +1,8 @@
+export declare function createTodoReadTool(): import("ai").Tool<Record<string, never>, string>;
+export declare function createTodoWriteTool(): import("ai").Tool<{
+    todos: {
+        content: string;
+        status: "pending" | "in_progress" | "completed";
+        id?: number | undefined;
+    }[];
+}, string>;

package/dist/cli/tools/todo.js

@@ -0,0 +1,59 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+let todos = [];
+let nextId = 1;
+export function createTodoReadTool() {
+    return tool({
+        description: 'Read the current task/todo list. Use this to check progress, ' +
+            'review remaining work, or decide what to do next during complex multi-step tasks.',
+        inputSchema: z.object({}),
+        execute: async () => {
+            if (todos.length === 0) {
+                return 'No tasks in the list.';
+            }
+            const pending = todos.filter(t => t.status === 'pending').length;
+            const inProgress = todos.filter(t => t.status === 'in_progress').length;
+            const completed = todos.filter(t => t.status === 'completed').length;
+            const lines = todos.map(t => {
+                const icon = t.status === 'completed' ? '[x]'
+                    : t.status === 'in_progress' ? '[~]'
+                        : '[ ]';
+                return `${icon} #${t.id}: ${t.content}`;
+            });
+            return [
+                `Tasks: ${completed}/${todos.length} done (${pending} pending, ${inProgress} in progress)`,
+                '',
+                ...lines,
+            ].join('\n');
+        },
+    });
+}
+export function createTodoWriteTool() {
+    return tool({
+        description: 'Create or update the task/todo list. Pass the full list of tasks — this replaces the current list. ' +
+            'Use this to plan work, track progress on multi-step tasks, and mark items as completed.',
+        inputSchema: z.object({
+            todos: z.array(z.object({
+                id: z.number().optional().describe('Task ID (omit for new tasks, include to update existing)'),
+                content: z.string().describe('Task description'),
+                status: z.enum(['pending', 'in_progress', 'completed']).describe('Task status'),
+            })).min(1).describe('The full task list (replaces current list)'),
+        }),
+        execute: async ({ todos: newTodos }) => {
+            todos = newTodos.map(t => ({
+                id: t.id ?? nextId++,
+                content: t.content,
+                status: t.status,
+            }));
+            // Ensure nextId stays ahead of all existing IDs
+            const maxId = Math.max(0, ...todos.map(t => t.id));
+            if (nextId <= maxId) {
+                nextId = maxId + 1;
+            }
+            const pending = todos.filter(t => t.status === 'pending').length;
+            const inProgress = todos.filter(t => t.status === 'in_progress').length;
+            const completed = todos.filter(t => t.status === 'completed').length;
+            return `Updated task list: ${todos.length} tasks (${completed} done, ${inProgress} in progress, ${pending} pending)`;
+        },
+    });
+}

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

@@ -0,0 +1,5 @@
+export declare function createWebFetchTool(): import("ai").Tool<{
+    url: string;
+    format: "text" | "markdown" | "html";
+    timeout?: number | undefined;
+}, string>;

package/dist/cli/tools/web-fetch.js

@@ -0,0 +1,116 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import TurndownService from 'turndown';
+const MAX_RESPONSE_SIZE = 5 * 1024 * 1024; // 5MB
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_TIMEOUT_MS = 120_000;
+export function createWebFetchTool() {
+    return tool({
+        description: 'Fetch content from a URL and return it as markdown, plain text, or raw HTML. ' +
+            'Use this to read documentation pages, API references, blog posts, or any web content. ' +
+            'Defaults to markdown format which works best for reading HTML pages.',
+        inputSchema: z.object({
+            url: z.string().describe('The URL to fetch (must start with http:// or https://)'),
+            format: z.enum(['markdown', 'text', 'html']).optional().default('markdown')
+                .describe('Output format: "markdown" (default, best for HTML pages), "text" (stripped), or "html" (raw)'),
+            timeout: z.number().optional().describe('Timeout in seconds (default: 30, max: 120)'),
+        }),
+        execute: async ({ url, format, timeout }) => {
+            if (!url.startsWith('http://') && !url.startsWith('https://')) {
+                return 'Error: URL must start with http:// or https://';
+            }
+            const timeoutMs = Math.min((timeout ?? DEFAULT_TIMEOUT_MS / 1000) * 1000, MAX_TIMEOUT_MS);
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            // Build Accept header based on requested format
+            let acceptHeader;
+            switch (format) {
+                case 'text':
+                    acceptHeader = 'text/plain;q=1.0, text/html;q=0.8, */*;q=0.1';
+                    break;
+                case 'html':
+                    acceptHeader = 'text/html;q=1.0, application/xhtml+xml;q=0.9, */*;q=0.1';
+                    break;
+                case 'markdown':
+                default:
+                    acceptHeader = 'text/html;q=1.0, text/plain;q=0.8, */*;q=0.1';
+                    break;
+            }
+            try {
+                const headers = {
+                    'User-Agent': 'Mozilla/5.0 (compatible; Awel/1.0)',
+                    'Accept': acceptHeader,
+                    'Accept-Language': 'en-US,en;q=0.9',
+                };
+                let response = await fetch(url, { signal: controller.signal, headers });
+                // Retry with honest UA if Cloudflare blocks the request
+                if (response.status === 403 && response.headers.get('cf-mitigated') === 'challenge') {
+                    response = await fetch(url, {
+                        signal: controller.signal,
+                        headers: { ...headers, 'User-Agent': 'Awel' },
+                    });
+                }
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    return `Error: Request failed with status ${response.status}`;
+                }
+                const contentLength = response.headers.get('content-length');
+                if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
+                    return 'Error: Response too large (exceeds 5MB limit)';
+                }
+                const buffer = await response.arrayBuffer();
+                if (buffer.byteLength > MAX_RESPONSE_SIZE) {
+                    return 'Error: Response too large (exceeds 5MB limit)';
+                }
+                const content = new TextDecoder().decode(buffer);
+                const contentType = response.headers.get('content-type') || '';
+                const isHTML = contentType.includes('text/html');
+                switch (format) {
+                    case 'markdown':
+                        return isHTML ? convertHTMLToMarkdown(content) : content;
+                    case 'text':
+                        return isHTML ? stripHTMLTags(content) : content;
+                    case 'html':
+                        return content;
+                    default:
+                        return content;
+                }
+            }
+            catch (err) {
+                clearTimeout(timeoutId);
+                if (err instanceof Error && err.name === 'AbortError') {
+                    return `Error: Request timed out after ${Math.round(timeoutMs / 1000)} seconds.`;
+                }
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+}
+function convertHTMLToMarkdown(html) {
+    const turndown = new TurndownService({
+        headingStyle: 'atx',
+        hr: '---',
+        bulletListMarker: '-',
+        codeBlockStyle: 'fenced',
+        emDelimiter: '*',
+    });
+    turndown.remove(['script', 'style', 'meta', 'link', 'noscript']);
+    return turndown.turndown(html);
+}
+function stripHTMLTags(html) {
+    // Remove script, style, and noscript blocks entirely
+    let text = html.replace(/<(script|style|noscript)[^>]*>[\s\S]*?<\/\1>/gi, '');
+    // Remove all remaining HTML tags
+    text = text.replace(/<[^>]+>/g, ' ');
+    // Decode common HTML entities
+    text = text
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ');
+    // Collapse whitespace
+    text = text.replace(/\s+/g, ' ').trim();
+    return text;
+}

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

@@ -0,0 +1,5 @@
+export declare function createWebSearchTool(): import("ai").Tool<{
+    query: string;
+    numResults: number;
+    type: "auto" | "fast" | "deep";
+}, string>;

package/dist/cli/tools/web-search.js

@@ -0,0 +1,74 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+const API_CONFIG = {
+    BASE_URL: 'https://mcp.exa.ai',
+    ENDPOINT: '/mcp',
+    DEFAULT_NUM_RESULTS: 8,
+    TIMEOUT_MS: 25_000,
+};
+export function createWebSearchTool() {
+    const today = new Date().toISOString().slice(0, 10);
+    return tool({
+        description: `Search the web for real-time information. Use this to find current documentation, ` +
+            `look up error messages, find API references, or research libraries and tools. ` +
+            `Today's date is ${today}. Returns search results with page content.`,
+        inputSchema: z.object({
+            query: z.string().describe('The search query'),
+            numResults: z.number().optional().default(8).describe('Number of results to return (default: 8)'),
+            type: z.enum(['auto', 'fast', 'deep']).optional().default('auto')
+                .describe('Search type: "auto" (balanced), "fast" (quick), or "deep" (comprehensive)'),
+        }),
+        execute: async ({ query, numResults, type }) => {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), API_CONFIG.TIMEOUT_MS);
+            try {
+                const response = await fetch(`${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINT}`, {
+                    method: 'POST',
+                    headers: {
+                        'accept': 'application/json, text/event-stream',
+                        'content-type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: 1,
+                        method: 'tools/call',
+                        params: {
+                            name: 'web_search_exa',
+                            arguments: {
+                                query,
+                                type: type || 'auto',
+                                numResults: numResults || API_CONFIG.DEFAULT_NUM_RESULTS,
+                                livecrawl: 'fallback',
+                            },
+                        },
+                    }),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    return `Search error (${response.status}): ${errorText}`;
+                }
+                const responseText = await response.text();
+                // Parse SSE response — Exa returns data as Server-Sent Events
+                const lines = responseText.split('\n');
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = JSON.parse(line.substring(6));
+                        if (data.result?.content?.length > 0) {
+                            return data.result.content[0].text;
+                        }
+                    }
+                }
+                return 'No search results found. Try a different query.';
+            }
+            catch (err) {
+                clearTimeout(timeoutId);
+                if (err instanceof Error && err.name === 'AbortError') {
+                    return 'Error: Search request timed out after 25 seconds.';
+                }
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+}

package/dist/cli/tools/write.d.ts

@@ -0,0 +1,4 @@
+export declare function createWriteTool(cwd: string): import("ai").Tool<{
+    file_path: string;
+    content: string;
+}, string>;