@bahulam/code 0.1.1

package/src/tools/tool-search.mjs

@@ -0,0 +1,77 @@
+/**
+ * ToolSearch Tool — deferred tool loading / search.
+ *
+ * Allows the agent to discover and load tools that are not
+ * in the default set. Supports searching MCP servers and
+ * deferred tool definitions.
+ */
+
+export const ToolSearchTool = {
+    name: 'ToolSearch',
+    description: 'Search for and load deferred tools by name or keyword.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Tool name or search keywords',
+            },
+            max_results: {
+                type: 'number',
+                description: 'Maximum results to return (default: 5)',
+            },
+        },
+        required: ['query'],
+    },
+
+    // Will be set by the registry when MCP tools are available
+    _mcpTools: [],
+    _registry: null,
+
+    validateInput(input) {
+        return input.query ? [] : ['query is required'];
+    },
+
+    async call(input) {
+        const query = input.query.toLowerCase();
+        const maxResults = input.max_results || 5;
+        const matches = [];
+
+        // Search MCP tools
+        for (const tool of this._mcpTools) {
+            const name = (tool.name || '').toLowerCase();
+            const desc = (tool.description || '').toLowerCase();
+            if (name.includes(query) || desc.includes(query)) {
+                matches.push({
+                    name: tool.name,
+                    description: tool.description,
+                    source: 'mcp',
+                });
+            }
+        }
+
+        // Search registry tools
+        if (this._registry) {
+            for (const tool of this._registry.list()) {
+                const name = (tool.name || '').toLowerCase();
+                const desc = (tool.description || '').toLowerCase();
+                if (name.includes(query) || desc.includes(query)) {
+                    matches.push({
+                        name: tool.name,
+                        description: tool.description,
+                        source: 'builtin',
+                    });
+                }
+            }
+        }
+
+        if (matches.length === 0) {
+            return `No tools found matching "${input.query}"`;
+        }
+
+        const limited = matches.slice(0, maxResults);
+        return limited.map(m =>
+            `[${m.source}] ${m.name}: ${m.description}`
+        ).join('\n');
+    },
+};

package/src/tools/web-fetch.mjs

@@ -0,0 +1,65 @@
+/**
+ * Web Fetch Tool — fetch URL content using built-in Node.js fetch.
+ */
+
+export const WebFetchTool = {
+    name: 'WebFetch',
+    description: 'Fetch content from a URL. Returns the response body as text.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'The URL to fetch' },
+            headers: {
+                type: 'object',
+                description: 'Optional HTTP headers',
+            },
+            max_length: {
+                type: 'number',
+                description: 'Max response length in characters (default: 50000)',
+            },
+        },
+        required: ['url'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!input.url) errors.push('url is required');
+        try {
+            new URL(input.url);
+        } catch {
+            errors.push('url must be a valid URL');
+        }
+        return errors;
+    },
+
+    async call(input) {
+        const maxLength = input.max_length || 50000;
+
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 30000);
+
+            const res = await fetch(input.url, {
+                headers: input.headers || {},
+                signal: controller.signal,
+                redirect: 'follow',
+            });
+
+            clearTimeout(timeout);
+
+            if (!res.ok) {
+                return `HTTP ${res.status}: ${res.statusText}`;
+            }
+
+            const contentType = res.headers.get('content-type') || '';
+            const text = await res.text();
+            const truncated = text.length > maxLength
+                ? text.slice(0, maxLength) + `\n...[truncated at ${maxLength} chars]`
+                : text;
+
+            return `Content-Type: ${contentType}\nLength: ${text.length}\n\n${truncated}`;
+        } catch (err) {
+            return `Fetch error: ${err.message}`;
+        }
+    },
+};

package/src/tools/web-search.mjs

@@ -0,0 +1,89 @@
+/**
+ * Web Search Tool — search the web via configurable API backends.
+ *
+ * Supports:
+ * - Brave Search API (BRAVE_API_KEY)
+ * - SearXNG (self-hosted, SEARXNG_URL)
+ * - Fallback: returns instructions to use web-fetch instead
+ */
+
+export const WebSearchTool = {
+    name: 'WebSearch',
+    description: 'Search the web for information. Requires BRAVE_API_KEY or SEARXNG_URL.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            limit: { type: 'number', description: 'Max results (default: 5)' },
+        },
+        required: ['query'],
+    },
+
+    validateInput(input) {
+        return input.query ? [] : ['query is required'];
+    },
+
+    async call(input) {
+        const limit = input.limit || 5;
+
+        // Try Brave Search API
+        const braveKey = process.env.BRAVE_API_KEY;
+        if (braveKey) {
+            return searchBrave(input.query, limit, braveKey);
+        }
+
+        // Try SearXNG
+        const searxUrl = process.env.SEARXNG_URL;
+        if (searxUrl) {
+            return searchSearxng(input.query, limit, searxUrl);
+        }
+
+        return 'No search API configured. Set BRAVE_API_KEY or SEARXNG_URL environment variable. ' +
+            'Alternatively, use the WebFetch tool to fetch specific URLs directly.';
+    },
+};
+
+async function searchBrave(query, limit, apiKey) {
+    try {
+        const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${limit}`;
+        const res = await fetch(url, {
+            headers: {
+                'Accept': 'application/json',
+                'X-Subscription-Token': apiKey,
+            },
+        });
+
+        if (!res.ok) return `Brave API error: ${res.status}`;
+
+        const data = await res.json();
+        const results = (data.web?.results || []).slice(0, limit);
+
+        if (results.length === 0) return 'No results found.';
+
+        return results.map((r, i) =>
+            `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.description || ''}`
+        ).join('\n\n');
+    } catch (err) {
+        return `Search error: ${err.message}`;
+    }
+}
+
+async function searchSearxng(query, limit, baseUrl) {
+    try {
+        const url = `${baseUrl}/search?q=${encodeURIComponent(query)}&format=json&categories=general`;
+        const res = await fetch(url);
+
+        if (!res.ok) return `SearXNG error: ${res.status}`;
+
+        const data = await res.json();
+        const results = (data.results || []).slice(0, limit);
+
+        if (results.length === 0) return 'No results found.';
+
+        return results.map((r, i) =>
+            `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.content || ''}`
+        ).join('\n\n');
+    } catch (err) {
+        return `Search error: ${err.message}`;
+    }
+}

package/src/tools/write.mjs

@@ -0,0 +1,55 @@
+/**
+ * Write Tool — matches Claude Code's exact behavior.
+ *
+ * Features:
+ * - Creates parent directories if needed
+ * - Requires Read first for existing file overwrites
+ * - No README creation unless explicitly asked
+ */
+import fs from 'fs';
+import path from 'path';
+import { hasBeenRead, markRead } from './read.mjs';
+
+export const WriteTool = {
+    name: 'Write',
+    description: 'Write content to a file. Creates parent dirs if needed.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Absolute path to the file' },
+            content: { type: 'string', description: 'The content to write' },
+        },
+        required: ['file_path', 'content'],
+    },
+    validateInput(input) {
+        const errors = [];
+        if (!input.file_path) errors.push('file_path required');
+        return errors;
+    },
+    async call(input) {
+        const filePath = path.resolve(input.file_path);
+
+        // Check if file already exists — require Read first for overwrites
+        if (fs.existsSync(filePath)) {
+            if (!hasBeenRead(filePath)) {
+                return `Error: File ${filePath} already exists. You must Read it first before overwriting.`;
+            }
+        }
+
+        // Create parent directory if it doesn't exist
+        const dir = path.dirname(filePath);
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+        } catch (e) {
+            return `Error creating directory ${dir}: ${e.message}`;
+        }
+
+        try {
+            fs.writeFileSync(filePath, input.content);
+            markRead(filePath); // Mark as read after writing
+            return `File written: ${filePath}`;
+        } catch (e) {
+            return `Error writing file: ${e.message}`;
+        }
+    },
+};