tuna-agent 0.1.96 → 0.1.97

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

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

package/dist/mcp/idea-server.js

@@ -0,0 +1,402 @@
+#!/usr/bin/env node
+/**
+ * Idea Bank MCP Server for Tuna Agent
+ *
+ * Stdio-based MCP server that exposes idea bank tools to Claude Code.
+ * Communicates with the Tuna API using agent token auth.
+ *
+ * Usage:
+ *   node idea-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 = '';
+    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: idea-server --api-url URL --token TOKEN --agent-id ID\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) {
+    // Claude Code uses newline-delimited JSON (not Content-Length framing)
+    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_idea',
+        description: 'Create a new idea in the idea bank. Captures app/product ideas from research, trends, or social media.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Name/title of the idea' },
+                category: { type: 'string', description: 'Category of the idea (e.g. SaaS, Mobile App, AI Tool, etc.)' },
+                source: { type: 'string', enum: ['trending', 'research', 'social'], description: 'Where the idea came from' },
+                strategy: { type: 'string', description: 'High-level strategy or approach for this idea (optional)' },
+                url: { type: 'string', description: 'Reference URL related to the idea (optional)' },
+                score: { type: 'number', description: 'Idea score/rating (optional)' },
+                estimated_difficulty: { type: 'string', enum: ['easy', 'medium', 'hard'], description: 'Estimated difficulty to build (optional)' },
+                monetization_model: { type: 'string', description: 'How this idea could make money (optional)' },
+                tags: { type: 'string', description: 'Comma-separated tags (optional, e.g. "ai,saas,b2b")' },
+                competitors: { type: 'string', description: 'Comma-separated competitor names (optional, e.g. "Notion,Coda,Airtable")' },
+                notes: { type: 'string', description: 'Additional notes about the idea (optional)' },
+            },
+            required: ['name', 'category', 'source'],
+        },
+    },
+    {
+        name: 'update_idea',
+        description: 'Update an existing idea. Can update any field including status, score, notes, tags, etc.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idea_id: { type: 'string', description: 'The ID of the idea to update' },
+                name: { type: 'string', description: 'New name (optional)' },
+                category: { type: 'string', description: 'New category (optional)' },
+                status: { type: 'string', enum: ['new', 'watching', 'validated', 'archived'], description: 'New status (optional)' },
+                score: { type: 'number', description: 'New score (optional)' },
+                notes: { type: 'string', description: 'New notes (optional)' },
+                strategy: { type: 'string', description: 'New strategy (optional)' },
+                url: { type: 'string', description: 'New URL (optional)' },
+                monetization_model: { type: 'string', description: 'New monetization model (optional)' },
+                estimated_difficulty: { type: 'string', enum: ['easy', 'medium', 'hard'], description: 'New estimated difficulty (optional)' },
+                tags: { type: 'string', description: 'Comma-separated tags (optional)' },
+                competitors: { type: 'string', description: 'Comma-separated competitor names (optional)' },
+                times_seen: { type: 'number', description: 'Number of times this idea has been seen (optional)' },
+            },
+            required: ['idea_id'],
+        },
+    },
+    {
+        name: 'list_ideas',
+        description: 'List ideas in the idea bank with optional filters. Returns ideas with status emoji indicators.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', enum: ['new', 'watching', 'validated', 'archived'], description: 'Filter by status (optional)' },
+                category: { type: 'string', description: 'Filter by category (optional)' },
+                source: { type: 'string', enum: ['trending', 'research', 'social'], description: 'Filter by source (optional)' },
+                agent_id: { type: 'string', description: 'Filter by agent ID (optional, defaults to current agent)' },
+                page: { type: 'number', description: 'Page number (optional, default 1)' },
+                limit: { type: 'number', description: 'Items per page (optional, default 20)' },
+                sort_by: { type: 'string', description: 'Field to sort by (optional, e.g. "score", "created_at")' },
+                sort_order: { type: 'string', enum: ['asc', 'desc'], description: 'Sort order (optional)' },
+            },
+        },
+    },
+    {
+        name: 'search_ideas',
+        description: 'Search ideas by keyword query. Searches across name, notes, tags, and other text fields.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query string' },
+                status: { type: 'string', enum: ['new', 'watching', 'validated', 'archived'], description: 'Filter by status (optional)' },
+                category: { type: 'string', description: 'Filter by category (optional)' },
+                page: { type: 'number', description: 'Page number (optional)' },
+                limit: { type: 'number', description: 'Items per page (optional)' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'archive_idea',
+        description: 'Archive an idea by setting its status to archived.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idea_id: { type: 'string', description: 'The ID of the idea to archive' },
+            },
+            required: ['idea_id'],
+        },
+    },
+    {
+        name: 'bulk_update_ideas',
+        description: 'Update multiple ideas at once. Useful for batch status changes, scoring, or categorization.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idea_ids: { type: 'string', description: 'Comma-separated list of idea IDs to update' },
+                status: { type: 'string', enum: ['new', 'watching', 'validated', 'archived'], description: 'New status for all ideas (optional)' },
+                score: { type: 'number', description: 'New score for all ideas (optional)' },
+                category: { type: 'string', description: 'New category for all ideas (optional)' },
+            },
+            required: ['idea_ids'],
+        },
+    },
+];
+// ===== Status Emoji Helper =====
+function statusEmoji(status) {
+    switch (status) {
+        case 'new': return '\u2B50'; // ⭐
+        case 'watching': return '\uD83D\uDC41'; // 👁
+        case 'validated': return '\u2705'; // ✅
+        case 'archived': return '\uD83D\uDCE6'; // 📦
+        default: return '\u2753'; // ❓
+    }
+}
+// ===== 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-idea-bank', version: '1.0.0' },
+                });
+                break;
+            case 'notifications/initialized':
+                // No response needed for notifications
+                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_idea': {
+                if (!args.name || !args.category || !args.source) {
+                    return { content: [{ type: 'text', text: 'Error: name, category, and source are required' }], isError: true };
+                }
+                const body = {
+                    name: args.name,
+                    category: args.category,
+                    source: args.source,
+                    agent_id: config.agentId,
+                };
+                if (args.strategy)
+                    body.strategy = args.strategy;
+                if (args.url)
+                    body.url = args.url;
+                if (args.score)
+                    body.score = Number(args.score);
+                if (args.estimated_difficulty)
+                    body.estimated_difficulty = args.estimated_difficulty;
+                if (args.monetization_model)
+                    body.monetization_model = args.monetization_model;
+                if (args.tags)
+                    body.tags = args.tags.split(',').map((t) => t.trim());
+                if (args.competitors)
+                    body.competitors = args.competitors.split(',').map((c) => c.trim());
+                if (args.notes)
+                    body.notes = args.notes;
+                const data = await apiCall(config, 'POST', '/agent-idea', body);
+                return { content: [{ type: 'text', text: `Idea "${data.name}" created (ID: ${data._id})` }] };
+            }
+            case 'update_idea': {
+                if (!args.idea_id) {
+                    return { content: [{ type: 'text', text: 'Error: idea_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.score)
+                    body.score = Number(args.score);
+                if (args.notes)
+                    body.notes = args.notes;
+                if (args.strategy)
+                    body.strategy = args.strategy;
+                if (args.url)
+                    body.url = args.url;
+                if (args.monetization_model)
+                    body.monetization_model = args.monetization_model;
+                if (args.estimated_difficulty)
+                    body.estimated_difficulty = args.estimated_difficulty;
+                if (args.tags)
+                    body.tags = args.tags.split(',').map((t) => t.trim());
+                if (args.competitors)
+                    body.competitors = args.competitors.split(',').map((c) => c.trim());
+                if (args.times_seen)
+                    body.times_seen = Number(args.times_seen);
+                const data = await apiCall(config, 'PUT', `/agent-idea/${args.idea_id}`, body);
+                return { content: [{ type: 'text', text: `Idea "${data.name}" updated (ID: ${data._id})` }] };
+            }
+            case 'list_ideas': {
+                const params = new URLSearchParams();
+                params.set('agent_id', args.agent_id || config.agentId);
+                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);
+                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-idea?${params.toString()}`);
+                const ideas = data.ideas || [];
+                if (ideas.length === 0) {
+                    return { content: [{ type: 'text', text: 'No ideas found.' }] };
+                }
+                const listing = ideas.map((idea) => {
+                    const emoji = statusEmoji(idea.status);
+                    const score = idea.score != null ? ` | Score: ${idea.score}` : '';
+                    const tags = idea.tags && idea.tags.length > 0 ? ` | Tags: ${idea.tags.join(', ')}` : '';
+                    return `- ${emoji} **${idea.name}** (ID: ${idea._id})\n  Category: ${idea.category} | Source: ${idea.source}${score}${tags}\n  Created: ${idea.created_at}`;
+                }).join('\n\n');
+                const total = data.total != null ? ` (total: ${data.total})` : '';
+                return { content: [{ type: 'text', text: `Found ${ideas.length} idea(s)${total}:\n\n${listing}` }] };
+            }
+            case 'search_ideas': {
+                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-idea/search?${params.toString()}`);
+                const ideas = data.ideas || [];
+                if (ideas.length === 0) {
+                    return { content: [{ type: 'text', text: `No ideas found matching "${args.query}".` }] };
+                }
+                const listing = ideas.map((idea) => {
+                    const emoji = statusEmoji(idea.status);
+                    const score = idea.score != null ? ` | Score: ${idea.score}` : '';
+                    const tags = idea.tags && idea.tags.length > 0 ? ` | Tags: ${idea.tags.join(', ')}` : '';
+                    return `- ${emoji} **${idea.name}** (ID: ${idea._id})\n  Category: ${idea.category} | Source: ${idea.source}${score}${tags}`;
+                }).join('\n\n');
+                const total = data.total != null ? ` (total: ${data.total})` : '';
+                return { content: [{ type: 'text', text: `Search results for "${args.query}" — ${ideas.length} idea(s)${total}:\n\n${listing}` }] };
+            }
+            case 'archive_idea': {
+                if (!args.idea_id) {
+                    return { content: [{ type: 'text', text: 'Error: idea_id is required' }], isError: true };
+                }
+                const data = await apiCall(config, 'PUT', `/agent-idea/${args.idea_id}/archive`, {});
+                return { content: [{ type: 'text', text: `Idea "${data.name}" archived (ID: ${data._id})` }] };
+            }
+            case 'bulk_update_ideas': {
+                if (!args.idea_ids) {
+                    return { content: [{ type: 'text', text: 'Error: idea_ids is required' }], isError: true };
+                }
+                const body = {
+                    idea_ids: args.idea_ids.split(',').map((id) => id.trim()),
+                };
+                if (args.status)
+                    body.status = args.status;
+                if (args.score)
+                    body.score = Number(args.score);
+                if (args.category)
+                    body.category = args.category;
+                if (!args.status && !args.score && !args.category) {
+                    return { content: [{ type: 'text', text: 'Error: at least one of status, score, or category is required' }], isError: true };
+                }
+                const data = await apiCall(config, 'PUT', '/agent-idea/bulk', body);
+                return { content: [{ type: 'text', text: `Bulk update complete: ${data.updated_count} idea(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(`[idea-mcp] Starting with agent ${config.agentId}\n`);
+    let buffer = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => {
+        buffer += chunk;
+        // Claude Code sends newline-delimited JSON (one JSON object per line)
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? ''; // Keep incomplete last line in buffer
+        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(`[idea-mcp] Error handling ${req.method}: ${err}\n`);
+                });
+            }
+            catch {
+                process.stderr.write(`[idea-mcp] Failed to parse JSON: ${trimmed.slice(0, 100)}\n`);
+            }
+        }
+    });
+    process.stdin.on('end', () => {
+        process.stderr.write('[idea-mcp] stdin closed, shutting down\n');
+        process.exit(0);
+    });
+}
+// ===== Main =====
+const config = parseArgs();
+startServer(config);
+export {};

package/dist/mcp/setup.js

@@ -378,6 +378,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 browserServerPath = path.join(__dirname, 'browser-server.js');
     const mcpServers = {
         'tuna-knowledge': {
@@ -389,6 +390,15 @@ export function setupMcpConfig(config) {
                 '--agent-id', config.agentId,
             ],
         },
+        'tuna-idea': {
+            command: process.execPath,
+            args: [
+                ideaServerPath,
+                '--api-url', config.apiUrl,
+                '--token', config.agentToken,
+                '--agent-id', config.agentId,
+            ],
+        },
         'tuna-browser': {
             command: process.execPath,
             args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],
@@ -420,6 +430,7 @@ export function getMcpConfigPath() {
  */
 export function writeAgentFolderMcpConfig(agentFolderPath, config) {
     const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
+    const ideaServerPath = path.join(__dirname, 'idea-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
@@ -443,6 +454,15 @@ export function writeAgentFolderMcpConfig(agentFolderPath, config) {
                     '--agent-id', config.agentId,
                 ],
             },
+            'tuna-idea': {
+                command: process.execPath,
+                args: [
+                    ideaServerPath,
+                    '--api-url', config.apiUrl,
+                    '--token', config.agentToken,
+                    '--agent-id', config.agentId,
+                ],
+            },
             'tuna-browser': {
                 command: process.execPath,
                 args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],

package/package.json

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