tuna-agent 0.1.111 → 0.1.112

package/dist/mcp/setup.js

@@ -379,6 +379,7 @@ function buildMem0McpConfig(agentName) {
 export function setupMcpConfig(config) {
     const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
     const ideaServerPath = path.join(__dirname, 'idea-server.js');
+    const toolServerPath = path.join(__dirname, 'tool-server.js');
     const browserServerPath = path.join(__dirname, 'browser-server.js');
     const mcpServers = {
         'tuna-knowledge': {
@@ -399,6 +400,15 @@ export function setupMcpConfig(config) {
             ],
             env: { TUNA_AGENT_TOKEN: config.agentToken },
         },
+        'tuna-tools': {
+            command: process.execPath,
+            args: [
+                toolServerPath,
+                '--api-url', config.apiUrl,
+                '--agent-id', config.agentId,
+            ],
+            env: { TUNA_AGENT_TOKEN: config.agentToken },
+        },
         'tuna-browser': {
             command: process.execPath,
             args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],
@@ -431,6 +441,7 @@ export function getMcpConfigPath() {
 export function writeAgentFolderMcpConfig(agentFolderPath, config, agentId) {
     const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
     const ideaServerPath = path.join(__dirname, 'idea-server.js');
+    const toolServerPath = path.join(__dirname, 'tool-server.js');
     const browserServerPath = path.join(__dirname, 'browser-server.js');
     // Derive agent name from folder path (e.g. ~/agents/co-founder → "co-founder")
     // config.name is the machine name, NOT the agent name
@@ -465,6 +476,15 @@ export function writeAgentFolderMcpConfig(agentFolderPath, config, agentId) {
                 ],
                 env: { TUNA_AGENT_TOKEN: config.agentToken },
             },
+            'tuna-tools': {
+                command: process.execPath,
+                args: [
+                    toolServerPath,
+                    '--api-url', config.apiUrl,
+                    '--agent-id', mcpAgentId,
+                ],
+                env: { TUNA_AGENT_TOKEN: config.agentToken },
+            },
             'tuna-browser': {
                 command: process.execPath,
                 args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],

package/dist/mcp/tool-server.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Tool Library MCP Server for Tuna Agent
+ *
+ * Stdio-based MCP server that exposes tool research/discovery tools to Claude Code.
+ * Communicates with the Tuna API using agent token auth.
+ *
+ * Usage:
+ *   node tool-server.js --api-url https://api.tuna.ai --token xxx --agent-id abc123
+ */
+export {};

package/dist/mcp/tool-server.js

@@ -0,0 +1,459 @@
+#!/usr/bin/env node
+/**
+ * Tool Library MCP Server for Tuna Agent
+ *
+ * Stdio-based MCP server that exposes tool research/discovery tools to Claude Code.
+ * Communicates with the Tuna API using agent token auth.
+ *
+ * Usage:
+ *   node tool-server.js --api-url https://api.tuna.ai --token xxx --agent-id abc123
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let apiUrl = '';
+    let token = process.env.TUNA_AGENT_TOKEN || '';
+    let agentId = '';
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--api-url' && args[i + 1])
+            apiUrl = args[++i];
+        else if (args[i] === '--token' && args[i + 1])
+            token = args[++i];
+        else if (args[i] === '--agent-id' && args[i + 1])
+            agentId = args[++i];
+    }
+    if (!apiUrl || !token || !agentId) {
+        process.stderr.write('Usage: tool-server --api-url URL [--token TOKEN] --agent-id ID\n');
+        process.stderr.write('Token can also be set via TUNA_AGENT_TOKEN env var\n');
+        process.exit(1);
+    }
+    return { apiUrl, token, agentId };
+}
+// ===== API Client =====
+async function apiCall(config, method, path, body) {
+    const url = `${config.apiUrl}${path}`;
+    const headers = {
+        'Authorization': `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+    };
+    const options = { method, headers };
+    if (body)
+        options.body = JSON.stringify(body);
+    const res = await fetch(url, options);
+    const json = await res.json();
+    if (!res.ok || (json.code && json.code >= 400)) {
+        throw new Error(json.message || `API error: ${res.status}`);
+    }
+    return json.data;
+}
+function sendResponse(res) {
+    process.stdout.write(JSON.stringify(res) + '\n');
+}
+function sendResult(id, result) {
+    sendResponse({ jsonrpc: '2.0', id: id ?? null, result });
+}
+function sendError(id, code, message) {
+    sendResponse({ jsonrpc: '2.0', id: id ?? null, error: { code, message } });
+}
+// ===== Tool Definitions =====
+const TOOLS = [
+    {
+        name: 'create_tool',
+        description: 'Create a new tool entry in the tool library. Captures open-source tools/technologies from research or discovery.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Name of the tool/technology' },
+                category: { type: 'string', description: 'Category (e.g. "ai/ml", "media", "productivity", "dev-tools", "health", "finance")' },
+                source: { type: 'string', enum: ['manual', 'discover', 'trending'], description: 'How this tool was found (default: manual)' },
+                description: { type: 'string', description: 'Overview of the tool' },
+                github_url: { type: 'string', description: 'GitHub repository URL' },
+                website_url: { type: 'string', description: 'Official website URL' },
+                stars: { type: 'number', description: 'GitHub stars count' },
+                license: { type: 'string', description: 'License type (e.g. MIT, Apache-2.0)' },
+                key_features: { type: 'string', description: 'Comma-separated key features' },
+                use_cases: { type: 'string', description: 'Comma-separated use cases' },
+                tech_stack: { type: 'string', description: 'Tech stack / languages used' },
+                pros: { type: 'string', description: 'Comma-separated pros' },
+                cons: { type: 'string', description: 'Comma-separated cons' },
+                alternatives: { type: 'string', description: 'Comma-separated alternative tools' },
+                combo_ideas: { type: 'string', description: 'Comma-separated ideas for combining with other tools' },
+                mobile_potential: { type: 'number', description: 'Mobile app potential score 1-5 (default: 3)' },
+                relevance: { type: 'string', description: 'Relevance notes for Tuna/app ideas' },
+                notes: { type: 'string', description: 'Additional notes' },
+                tags: { type: 'string', description: 'Comma-separated tags' },
+            },
+            required: ['name', 'category'],
+        },
+    },
+    {
+        name: 'update_tool',
+        description: 'Update an existing tool entry. Can update any field including status, score, notes, etc.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tool_id: { type: 'string', description: 'The ID of the tool to update' },
+                name: { type: 'string', description: 'New name' },
+                category: { type: 'string', description: 'New category' },
+                status: { type: 'string', enum: ['new', 'researched', 'archived'], description: 'New status' },
+                source: { type: 'string', enum: ['manual', 'discover', 'trending'], description: 'New source' },
+                description: { type: 'string', description: 'New description' },
+                github_url: { type: 'string', description: 'New GitHub URL' },
+                website_url: { type: 'string', description: 'New website URL' },
+                stars: { type: 'number', description: 'New stars count' },
+                license: { type: 'string', description: 'New license' },
+                key_features: { type: 'string', description: 'Comma-separated key features' },
+                use_cases: { type: 'string', description: 'Comma-separated use cases' },
+                tech_stack: { type: 'string', description: 'New tech stack' },
+                pros: { type: 'string', description: 'Comma-separated pros' },
+                cons: { type: 'string', description: 'Comma-separated cons' },
+                alternatives: { type: 'string', description: 'Comma-separated alternatives' },
+                combo_ideas: { type: 'string', description: 'Comma-separated combo ideas' },
+                mobile_potential: { type: 'number', description: 'New mobile potential score 1-5' },
+                relevance: { type: 'string', description: 'New relevance notes' },
+                notes: { type: 'string', description: 'New notes' },
+                tags: { type: 'string', description: 'Comma-separated tags' },
+            },
+            required: ['tool_id'],
+        },
+    },
+    {
+        name: 'list_tools',
+        description: 'List tools in the library with optional filters. Returns tools with status indicators.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', enum: ['new', 'researched', 'archived'], description: 'Filter by status' },
+                category: { type: 'string', description: 'Filter by category' },
+                source: { type: 'string', enum: ['manual', 'discover', 'trending'], description: 'Filter by source' },
+                agent_id: { type: 'string', description: 'Filter by agent ID (defaults to current agent)' },
+                page: { type: 'number', description: 'Page number (default 1)' },
+                limit: { type: 'number', description: 'Items per page (default 20)' },
+                sort_by: { type: 'string', description: 'Field to sort by (e.g. "mobile_potential", "stars", "created_at")' },
+                sort_order: { type: 'string', enum: ['asc', 'desc'], description: 'Sort order' },
+            },
+        },
+    },
+    {
+        name: 'search_tools',
+        description: 'Search tools by keyword query. Searches across name, description, notes, and tags.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query string' },
+                status: { type: 'string', enum: ['new', 'researched', 'archived'], description: 'Filter by status' },
+                category: { type: 'string', description: 'Filter by category' },
+                page: { type: 'number', description: 'Page number' },
+                limit: { type: 'number', description: 'Items per page' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'archive_tool',
+        description: 'Archive a tool by setting its status to archived.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tool_id: { type: 'string', description: 'The ID of the tool to archive' },
+            },
+            required: ['tool_id'],
+        },
+    },
+    {
+        name: 'bulk_update_tools',
+        description: 'Update multiple tools at once. Useful for batch status changes or categorization.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tool_ids: { type: 'string', description: 'Comma-separated list of tool IDs to update' },
+                status: { type: 'string', enum: ['new', 'researched', 'archived'], description: 'New status for all tools' },
+                category: { type: 'string', description: 'New category for all tools' },
+                mobile_potential: { type: 'number', description: 'New mobile potential score for all tools' },
+            },
+            required: ['tool_ids'],
+        },
+    },
+];
+// ===== Status Emoji Helper =====
+function statusEmoji(status) {
+    switch (status) {
+        case 'new': return '\u2B50'; // ⭐
+        case 'researched': return '\uD83D\uDD2C'; // 🔬
+        case 'archived': return '\uD83D\uDCE6'; // 📦
+        default: return '\u2753'; // ❓
+    }
+}
+// ===== Helper: parse comma-separated strings to arrays =====
+function parseCSV(value) {
+    if (!value)
+        return undefined;
+    return value.split(',').map((s) => s.trim()).filter(Boolean);
+}
+// ===== Request Handler =====
+async function handleRequest(config, req) {
+    try {
+        switch (req.method) {
+            case 'initialize':
+                sendResult(req.id, {
+                    protocolVersion: '2024-11-05',
+                    capabilities: { tools: {} },
+                    serverInfo: { name: 'tuna-tool-library', version: '1.0.0' },
+                });
+                break;
+            case 'notifications/initialized':
+                break;
+            case 'tools/list':
+                sendResult(req.id, { tools: TOOLS });
+                break;
+            case 'tools/call': {
+                const toolName = req.params?.name ?? '';
+                const args = req.params?.arguments ?? {};
+                const result = await handleToolCall(config, toolName, args);
+                sendResult(req.id, result);
+                break;
+            }
+            case 'ping':
+                sendResult(req.id, {});
+                break;
+            default:
+                if (req.id !== undefined) {
+                    sendError(req.id, -32601, `Method not found: ${req.method}`);
+                }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (req.id !== undefined) {
+            sendError(req.id, -32603, message);
+        }
+    }
+}
+async function handleToolCall(config, toolName, args) {
+    try {
+        switch (toolName) {
+            case 'create_tool': {
+                if (!args.name || !args.category) {
+                    return { content: [{ type: 'text', text: 'Error: name and category are required' }], isError: true };
+                }
+                const body = {
+                    name: args.name,
+                    category: args.category,
+                    agent_id: config.agentId,
+                };
+                if (args.source)
+                    body.source = args.source;
+                if (args.description)
+                    body.description = args.description;
+                if (args.github_url)
+                    body.github_url = args.github_url;
+                if (args.website_url)
+                    body.website_url = args.website_url;
+                if (args.stars)
+                    body.stars = Number(args.stars);
+                if (args.license)
+                    body.license = args.license;
+                if (args.key_features)
+                    body.key_features = parseCSV(args.key_features);
+                if (args.use_cases)
+                    body.use_cases = parseCSV(args.use_cases);
+                if (args.tech_stack)
+                    body.tech_stack = args.tech_stack;
+                if (args.pros)
+                    body.pros = parseCSV(args.pros);
+                if (args.cons)
+                    body.cons = parseCSV(args.cons);
+                if (args.alternatives)
+                    body.alternatives = parseCSV(args.alternatives);
+                if (args.combo_ideas)
+                    body.combo_ideas = parseCSV(args.combo_ideas);
+                if (args.mobile_potential)
+                    body.mobile_potential = Number(args.mobile_potential);
+                if (args.relevance)
+                    body.relevance = args.relevance;
+                if (args.notes)
+                    body.notes = args.notes;
+                if (args.tags)
+                    body.tags = parseCSV(args.tags);
+                const data = await apiCall(config, 'POST', '/agent-tool', body);
+                return { content: [{ type: 'text', text: `Tool "${data.name}" created (ID: ${data._id})` }] };
+            }
+            case 'update_tool': {
+                if (!args.tool_id) {
+                    return { content: [{ type: 'text', text: 'Error: tool_id is required' }], isError: true };
+                }
+                const body = {};
+                if (args.name)
+                    body.name = args.name;
+                if (args.category)
+                    body.category = args.category;
+                if (args.status)
+                    body.status = args.status;
+                if (args.source)
+                    body.source = args.source;
+                if (args.description)
+                    body.description = args.description;
+                if (args.github_url)
+                    body.github_url = args.github_url;
+                if (args.website_url)
+                    body.website_url = args.website_url;
+                if (args.stars)
+                    body.stars = Number(args.stars);
+                if (args.license)
+                    body.license = args.license;
+                if (args.key_features)
+                    body.key_features = parseCSV(args.key_features);
+                if (args.use_cases)
+                    body.use_cases = parseCSV(args.use_cases);
+                if (args.tech_stack)
+                    body.tech_stack = args.tech_stack;
+                if (args.pros)
+                    body.pros = parseCSV(args.pros);
+                if (args.cons)
+                    body.cons = parseCSV(args.cons);
+                if (args.alternatives)
+                    body.alternatives = parseCSV(args.alternatives);
+                if (args.combo_ideas)
+                    body.combo_ideas = parseCSV(args.combo_ideas);
+                if (args.mobile_potential)
+                    body.mobile_potential = Number(args.mobile_potential);
+                if (args.relevance)
+                    body.relevance = args.relevance;
+                if (args.notes)
+                    body.notes = args.notes;
+                if (args.tags)
+                    body.tags = parseCSV(args.tags);
+                const data = await apiCall(config, 'PUT', `/agent-tool/${args.tool_id}`, body);
+                return { content: [{ type: 'text', text: `Tool "${data.name}" updated (ID: ${data._id})` }] };
+            }
+            case 'list_tools': {
+                const params = new URLSearchParams();
+                if (args.agent_id)
+                    params.set('agent_id', args.agent_id);
+                if (args.status)
+                    params.set('status', args.status);
+                if (args.category)
+                    params.set('category', args.category);
+                if (args.source)
+                    params.set('source', args.source);
+                if (args.page)
+                    params.set('page', args.page);
+                if (args.limit)
+                    params.set('limit', args.limit || '100');
+                if (args.sort_by)
+                    params.set('sort_by', args.sort_by);
+                if (args.sort_order)
+                    params.set('sort_order', args.sort_order);
+                const data = await apiCall(config, 'GET', `/agent-tool?${params.toString()}`);
+                const tools = data.items || [];
+                if (tools.length === 0) {
+                    return { content: [{ type: 'text', text: 'No tools found.' }] };
+                }
+                const listing = tools.map((tool) => {
+                    const emoji = statusEmoji(tool.status);
+                    const mp = tool.mobile_potential != null ? ` | Mobile: ${tool.mobile_potential}/5` : '';
+                    const stars = tool.stars ? ` | Stars: ${tool.stars}` : '';
+                    const tags = tool.tags && tool.tags.length > 0 ? ` | Tags: ${tool.tags.join(', ')}` : '';
+                    return `- ${emoji} **${tool.name}** (ID: ${tool._id})\n  Category: ${tool.category} | Source: ${tool.source}${mp}${stars}${tags}\n  Created: ${tool.created_at}`;
+                }).join('\n\n');
+                const total = data.total != null ? ` (total: ${data.total})` : '';
+                return { content: [{ type: 'text', text: `Found ${tools.length} tool(s)${total}:\n\n${listing}` }] };
+            }
+            case 'search_tools': {
+                if (!args.query) {
+                    return { content: [{ type: 'text', text: 'Error: query is required' }], isError: true };
+                }
+                const params = new URLSearchParams();
+                params.set('q', args.query);
+                if (args.status)
+                    params.set('status', args.status);
+                if (args.category)
+                    params.set('category', args.category);
+                if (args.page)
+                    params.set('page', args.page);
+                if (args.limit)
+                    params.set('limit', args.limit);
+                const data = await apiCall(config, 'GET', `/agent-tool/search?${params.toString()}`);
+                const tools = data.items || [];
+                if (tools.length === 0) {
+                    return { content: [{ type: 'text', text: `No tools found matching "${args.query}".` }] };
+                }
+                const listing = tools.map((tool) => {
+                    const emoji = statusEmoji(tool.status);
+                    const mp = tool.mobile_potential != null ? ` | Mobile: ${tool.mobile_potential}/5` : '';
+                    const stars = tool.stars ? ` | Stars: ${tool.stars}` : '';
+                    const tags = tool.tags && tool.tags.length > 0 ? ` | Tags: ${tool.tags.join(', ')}` : '';
+                    return `- ${emoji} **${tool.name}** (ID: ${tool._id})\n  Category: ${tool.category} | Source: ${tool.source}${mp}${stars}${tags}`;
+                }).join('\n\n');
+                const total = data.total != null ? ` (total: ${data.total})` : '';
+                return { content: [{ type: 'text', text: `Search results for "${args.query}" — ${tools.length} tool(s)${total}:\n\n${listing}` }] };
+            }
+            case 'archive_tool': {
+                if (!args.tool_id) {
+                    return { content: [{ type: 'text', text: 'Error: tool_id is required' }], isError: true };
+                }
+                const data = await apiCall(config, 'PUT', `/agent-tool/${args.tool_id}/archive`, {});
+                return { content: [{ type: 'text', text: `Tool "${data.name}" archived (ID: ${data._id})` }] };
+            }
+            case 'bulk_update_tools': {
+                if (!args.tool_ids) {
+                    return { content: [{ type: 'text', text: 'Error: tool_ids is required' }], isError: true };
+                }
+                const body = {
+                    tool_ids: args.tool_ids.split(',').map((id) => id.trim()),
+                    data: {},
+                };
+                const updateData = body.data;
+                if (args.status)
+                    updateData.status = args.status;
+                if (args.category)
+                    updateData.category = args.category;
+                if (args.mobile_potential)
+                    updateData.mobile_potential = Number(args.mobile_potential);
+                if (Object.keys(updateData).length === 0) {
+                    return { content: [{ type: 'text', text: 'Error: at least one of status, category, or mobile_potential is required' }], isError: true };
+                }
+                const data = await apiCall(config, 'PUT', '/agent-tool/bulk', body);
+                return { content: [{ type: 'text', text: `Bulk update complete: ${data.updated_count} tool(s) updated.` }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${toolName}` }], isError: true };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+}
+// ===== Stdio Transport =====
+function startServer(config) {
+    process.stderr.write(`[tool-mcp] Starting with agent ${config.agentId}\n`);
+    let buffer = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => {
+        buffer += chunk;
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const req = JSON.parse(trimmed);
+                handleRequest(config, req).catch((err) => {
+                    process.stderr.write(`[tool-mcp] Error handling ${req.method}: ${err}\n`);
+                });
+            }
+            catch {
+                process.stderr.write(`[tool-mcp] Failed to parse JSON: ${trimmed.slice(0, 100)}\n`);
+            }
+        }
+    });
+    process.stdin.on('end', () => {
+        process.stderr.write('[tool-mcp] stdin closed, shutting down\n');
+        process.exit(0);
+    });
+}
+// ===== Main =====
+const config = parseArgs();
+startServer(config);
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.111",
+  "version": "0.1.112",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"