talkiebot 0.2.0 → 0.3.0

package/mcp-server/index.js

@@ -10,685 +10,322 @@ import { spawn, exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import { randomUUID } from 'crypto';
 
 const execAsync = promisify(exec);
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const TALKIE_DIR = join(__dirname, '..');
 const TALKIE_PORT = parseInt(process.env.TALKIE_PORT || '5173', 10);
 const TALKIE_URL = `https://localhost:${TALKIE_PORT}`;
 
-// Allow self-signed certificates for local dev
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
 
 let talkieProcess = null;
 
-// Check if Talkie is running
-async function isTalkieRunning() {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/status`);
-    return response.ok;
-  } catch {
-    return false;
-  }
+// ─── JSON response wrapper ───
+function jsonResult(data) {
+  return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
 }
 
-// Launch Talkie using npx
-async function launchTalkie() {
-  if (await isTalkieRunning()) {
-    // Already running, just open the browser (prefer Chrome for Web Speech API)
-    exec(`open -a "Google Chrome" ${TALKIE_URL} 2>/dev/null || open ${TALKIE_URL}`);
-    return { success: true, message: 'Talkie is already running (use Chrome/Edge for voice)', url: TALKIE_URL };
-  }
-
-  return new Promise((resolve) => {
-    // Use npx talkie to start the server
-    talkieProcess = spawn('npx', ['talkie'], {
-      detached: true,
-      stdio: 'ignore',
-      env: { ...process.env, TALKIE_PORT: String(TALKIE_PORT) },
-    });
-
-    talkieProcess.unref();
-
-    // Wait for server to be ready
-    let attempts = 0;
-    const checkReady = setInterval(async () => {
-      attempts++;
-      if (await isTalkieRunning()) {
-        clearInterval(checkReady);
-        resolve({ success: true, message: 'Talkie launched', url: TALKIE_URL });
-      } else if (attempts > 30) {
-        clearInterval(checkReady);
-        resolve({ success: false, message: 'Talkie failed to start' });
-      }
-    }, 500);
-  });
+// ─── HTTP helpers (for server-dependent tools) ───
+async function apiGet(path) {
+  const r = await fetch(`${TALKIE_URL}${path}`);
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
 }
-
-// Get status from Talkie
-async function getStatus() {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/status`);
-    if (response.ok) {
-      return await response.json();
-    }
-    return { running: false };
-  } catch {
-    return { running: false };
-  }
+async function apiPost(path, body) {
+  const r = await fetch(`${TALKIE_URL}${path}`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
 }
-
-// Get latest transcript
-async function getTranscript() {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/transcript`);
-    if (response.ok) {
-      return await response.json();
-    }
-    return { transcript: null, error: 'Failed to get transcript' };
-  } catch {
-    return { transcript: null, error: 'Talkie not running' };
-  }
+async function apiPatch(path, body) {
+  const r = await fetch(`${TALKIE_URL}${path}`, { method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
 }
-
-// Get conversation history
-async function getHistory() {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/history`);
-    if (response.ok) {
-      return await response.json();
-    }
-    return { messages: [], error: 'Failed to get history' };
-  } catch {
-    return { messages: [], error: 'Talkie not running' };
-  }
+async function apiPut(path, body) {
+  const r = await fetch(`${TALKIE_URL}${path}`, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
 }
-
-// Get Claude Code session info
-async function getSession() {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/session`);
-    if (response.ok) {
-      return await response.json();
-    }
-    return { sessionId: null, error: 'Failed to get session' };
-  } catch {
-    return { sessionId: null, error: 'Talkie not running' };
-  }
+async function apiDelete(path) {
+  const r = await fetch(`${TALKIE_URL}${path}`, { method: 'DELETE' });
+  return r.ok ? await r.json() : { error: `API error (${r.status}): ${await r.text()}` };
 }
 
-// Set Claude Code session ID
-async function setSession(sessionId) {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/session`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ sessionId }),
-    });
-    if (response.ok) {
-      return await response.json();
-    }
-    return { success: false, error: 'Failed to set session' };
-  } catch {
-    return { success: false, error: 'Talkie not running' };
-  }
-}
+// ─── Database layer (lazy-loaded, for data tools) ───
+let db = null;
 
-// Disconnect Claude Code session
-async function disconnectSession() {
+async function getDb() {
+  if (db) return db;
   try {
-    const response = await fetch(`${TALKIE_URL}/api/session`, {
-      method: 'DELETE',
-    });
-    if (response.ok) {
-      return await response.json();
-    }
-    return { success: false, error: 'Failed to disconnect session' };
-  } catch {
-    return { success: false, error: 'Talkie not running' };
+    const dbIndex = await import(join(__dirname, '..', 'server', 'db', 'index.js'));
+    dbIndex.initDb();
+    db = {
+      convos: await import(join(__dirname, '..', 'server', 'db', 'repositories', 'conversations.js')),
+      msgs: await import(join(__dirname, '..', 'server', 'db', 'repositories', 'messages.js')),
+      plans: await import(join(__dirname, '..', 'server', 'db', 'repositories', 'plans.js')),
+      search: await import(join(__dirname, '..', 'server', 'db', 'repositories', 'search.js')),
+      activities: await import(join(__dirname, '..', 'server', 'db', 'repositories', 'activities.js')),
+    };
+    return db;
+  } catch (err) {
+    console.error('DB init failed, falling back to HTTP:', err.message);
+    return null;
   }
 }
 
-// Get pending message (for IPC mode)
-async function getPendingMessage() {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/pending`);
-    if (response.ok) {
-      return await response.json();
-    }
-    return { pending: null, error: 'Failed to get pending message' };
-  } catch {
-    return { pending: null, error: 'Talkie not running' };
-  }
-}
-
-// Respond to pending message (for IPC mode)
-async function respondToMessage(content) {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/respond`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ content }),
-    });
-    if (response.ok) {
-      return await response.json();
-    }
-    return { success: false, error: 'Failed to respond' };
-  } catch {
-    return { success: false, error: 'Talkie not running' };
-  }
-}
-
-// Update state
-async function updateState(stateUpdate) {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/state`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(stateUpdate),
-    });
-    if (response.ok) {
-      return await response.json();
-    }
-    return { success: false, error: 'Failed to update state' };
-  } catch {
-    return { success: false, error: 'Talkie not running' };
-  }
+// ─── Server detection ───
+async function isTalkieRunning() {
+  try { return (await fetch(`${TALKIE_URL}/api/status`)).ok; }
+  catch { return false; }
 }
 
-// Analyze an image
-async function analyzeImage(dataUrl, fileName, apiKey) {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/analyze-image`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ dataUrl, fileName, apiKey }),
-    });
-    if (response.ok) {
-      return await response.json();
-    }
-    const error = await response.text();
-    return { error: `Failed to analyze image: ${error}` };
-  } catch {
-    return { error: 'Talkie not running' };
-  }
+function serverNotRunning() {
+  return { error: 'Talkie server not running. Data tools work offline. Start server with: npx talkiebot' };
 }
 
-// Open URL in browser
-async function openUrl(url) {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/open-url`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ url }),
-    });
-    if (response.ok) {
-      return await response.json();
-    }
-    return { success: false, error: 'Failed to open URL' };
-  } catch {
-    return { success: false, error: 'Talkie not running' };
-  }
+async function serverCall(fn) {
+  try { return await fn(); }
+  catch { return serverNotRunning(); }
 }
 
-// Job management
-async function createJob(conversationId, prompt) {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/jobs`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ conversationId, prompt, source: 'mcp' }),
-    });
-    if (response.ok) {
-      return await response.json();
-    }
-    const error = await response.text();
-    return { error: `Failed to create job: ${error}` };
-  } catch {
-    return { error: 'Talkie not running' };
+// ─── Launch ───
+async function launchTalkie() {
+  if (await isTalkieRunning()) {
+    exec(`open -a "Google Chrome" ${TALKIE_URL} 2>/dev/null || open ${TALKIE_URL}`);
+    return { success: true, message: 'Talkie is already running', url: TALKIE_URL };
   }
+  return new Promise((resolve) => {
+    talkieProcess = spawn('npx', ['talkie'], { detached: true, stdio: 'ignore', env: { ...process.env, TALKIE_PORT: String(TALKIE_PORT) } });
+    talkieProcess.unref();
+    let attempts = 0;
+    const check = setInterval(async () => {
+      if (await isTalkieRunning()) { clearInterval(check); resolve({ success: true, message: 'Talkie launched', url: TALKIE_URL }); }
+      else if (++attempts > 30) { clearInterval(check); resolve({ success: false, message: 'Talkie failed to start' }); }
+    }, 500);
+  });
 }
 
-async function getJobStatus(jobId) {
-  try {
-    const response = await fetch(`${TALKIE_URL}/api/jobs/${jobId}`);
-    if (response.ok) {
-      return await response.json();
-    }
-    return { error: 'Job not found' };
-  } catch {
-    return { error: 'Talkie not running' };
+// ─── Export formatter ───
+function formatMarkdown(conv, messages, activities) {
+  let md = `# ${conv.title || 'Untitled'}\n\n`;
+  if (conv.created_at) md += `*Created: ${new Date(conv.created_at).toLocaleString()}*\n\n---\n\n`;
+  for (const msg of messages) {
+    md += `**${msg.role === 'user' ? 'You' : 'Assistant'}:**\n\n${msg.content}\n\n---\n\n`;
   }
-}
-
-async function listTalkieJobs(status) {
-  try {
-    const params = status ? `?status=${status}` : '';
-    const response = await fetch(`${TALKIE_URL}/api/jobs${params}`);
-    if (response.ok) {
-      return await response.json();
-    }
-    return { jobs: [], error: 'Failed to list jobs' };
-  } catch {
-    return { jobs: [], error: 'Talkie not running' };
+  if (activities.length) {
+    md += '## Tool Activity\n\n';
+    for (const a of activities) md += `- **${a.tool}** (${a.status})${a.duration ? ` ${a.duration}ms` : ''}\n`;
   }
+  return md;
 }
 
-// Create MCP server
+// ─── MCP Server ───
 const server = new Server(
-  {
-    name: 'talkie',
-    version: '0.2.0',
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
+  { name: 'talkie', version: '0.3.0' },
+  { capabilities: { tools: {} } }
 );
 
-// List available tools
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      // Core tools
-      {
-        name: 'launch_talkie',
-        description: 'Launch the Talkie voice interface in a browser. Use this when the user wants to interact with voice.',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-          required: [],
-        },
-      },
-      {
-        name: 'get_talkie_status',
-        description: 'Check if Talkie is running and get its current state (idle, listening, thinking, speaking).',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-          required: [],
-        },
-      },
-      {
-        name: 'get_transcript',
-        description: 'Get the latest voice transcript from Talkie. Use after user has spoken.',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-          required: [],
-        },
-      },
-      {
-        name: 'get_conversation_history',
-        description: 'Get the full conversation history from the current tape/conversation in Talkie.',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-          required: [],
-        },
-      },
-      // Session management tools
-      {
-        name: 'get_claude_session',
-        description: 'Get the current Claude Code session ID if one is connected.',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-          required: [],
-        },
-      },
-      {
-        name: 'set_claude_session',
-        description: 'Set the Claude Code session ID to connect Talkie to your session.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            sessionId: {
-              type: 'string',
-              description: 'The Claude Code session ID to connect to',
-            },
-          },
-          required: ['sessionId'],
-        },
-      },
-      {
-        name: 'disconnect_claude_session',
-        description: 'Disconnect the current Claude Code session.',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-          required: [],
-        },
-      },
-      // IPC tools for Claude Code integration
-      {
-        name: 'get_pending_message',
-        description: 'Check if there is a pending message from Talkie waiting for a response. Use this to poll for user messages in IPC mode.',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-          required: [],
-        },
-      },
-      {
-        name: 'respond_to_talkie',
-        description: 'Send a response back to Talkie. Use this in IPC mode to respond to a pending message.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            content: {
-              type: 'string',
-              description: 'The response content to send to Talkie',
-            },
-          },
-          required: ['content'],
-        },
-      },
-      // State management
-      {
-        name: 'update_talkie_state',
-        description: 'Update Talkie state (avatar state, transcript, messages, etc.).',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            avatarState: {
-              type: 'string',
-              enum: ['idle', 'listening', 'thinking', 'speaking'],
-              description: 'The avatar state to set',
-            },
-            transcript: {
-              type: 'string',
-              description: 'Set the current transcript text',
-            },
-          },
-          required: [],
-        },
-      },
-      // Media tools
-      {
-        name: 'analyze_image',
-        description: 'Analyze an image using Claude vision API. Returns a description of the image content.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            dataUrl: {
-              type: 'string',
-              description: 'Base64 data URL of the image (e.g., data:image/png;base64,...)',
-            },
-            fileName: {
-              type: 'string',
-              description: 'Optional filename for the image',
-            },
-            apiKey: {
-              type: 'string',
-              description: 'Optional Anthropic API key (uses ANTHROPIC_API_KEY env var if not provided)',
-            },
-          },
-          required: ['dataUrl'],
-        },
-      },
-      {
-        name: 'open_url',
-        description: 'Open a URL in the default browser.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            url: {
-              type: 'string',
-              description: 'The URL to open (must be http or https)',
-            },
-          },
-          required: ['url'],
-        },
-      },
-      // Job tools
-      {
-        name: 'create_talkie_job',
-        description: 'Create a background job in Talkie. The task runs asynchronously and you get a job ID back immediately. Use get_talkie_job to check on progress.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            conversationId: {
-              type: 'string',
-              description: 'The conversation ID to run the job in',
-            },
-            prompt: {
-              type: 'string',
-              description: 'The task/prompt to execute',
-            },
-          },
-          required: ['conversationId', 'prompt'],
-        },
-      },
-      {
-        name: 'get_talkie_job',
-        description: 'Get the status and result of a background job.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            jobId: {
-              type: 'string',
-              description: 'The job ID to check',
-            },
-          },
-          required: ['jobId'],
-        },
-      },
-      {
-        name: 'list_talkie_jobs',
-        description: 'List background jobs, optionally filtered by status.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            status: {
-              type: 'string',
-              enum: ['queued', 'running', 'completed', 'failed', 'cancelled'],
-              description: 'Filter by job status',
-            },
-          },
-          required: [],
-        },
-      },
-    ],
-  };
-});
-
-// Handle tool calls
+// ─── Tool Definitions (30 tools) ───
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    // ── Server tools (require running Talkie server) ──
+    { name: 'launch_talkie', description: 'Launch the Talkie voice interface in a browser.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'get_talkie_status', description: 'Check if Talkie is running and get its current state.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'get_transcript', description: 'Get the latest voice transcript from Talkie.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'get_conversation_history', description: 'Get the full conversation history from the current tape in Talkie.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'get_claude_session', description: 'Get the current Claude Code session ID.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'set_claude_session', description: 'Connect Talkie to a Claude Code session.', inputSchema: { type: 'object', properties: { sessionId: { type: 'string', description: 'Session ID to connect to' } }, required: ['sessionId'] } },
+    { name: 'disconnect_claude_session', description: 'Disconnect the current Claude Code session.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'get_pending_message', description: 'Poll for a pending user message in IPC mode.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'respond_to_talkie', description: 'Send a response back to Talkie in IPC mode.', inputSchema: { type: 'object', properties: { content: { type: 'string', description: 'Response content' } }, required: ['content'] } },
+    { name: 'update_talkie_state', description: 'Update Talkie UI state (avatar state, transcript).', inputSchema: { type: 'object', properties: { avatarState: { type: 'string', enum: ['idle', 'listening', 'thinking', 'speaking'], description: 'Avatar state' }, transcript: { type: 'string', description: 'Transcript text' } }, required: [] } },
+    { name: 'analyze_image', description: 'Analyze an image using Claude vision API.', inputSchema: { type: 'object', properties: { dataUrl: { type: 'string', description: 'Base64 data URL of the image' }, fileName: { type: 'string', description: 'Optional filename' }, apiKey: { type: 'string', description: 'Optional Anthropic API key' } }, required: ['dataUrl'] } },
+    { name: 'open_url', description: 'Open a URL in the default browser.', inputSchema: { type: 'object', properties: { url: { type: 'string', description: 'URL to open' } }, required: ['url'] } },
+    { name: 'create_talkie_job', description: 'Create a background job in Talkie.', inputSchema: { type: 'object', properties: { conversationId: { type: 'string', description: 'Conversation ID' }, prompt: { type: 'string', description: 'Task/prompt to execute' } }, required: ['conversationId', 'prompt'] } },
+    { name: 'get_talkie_job', description: 'Get the status and result of a background job.', inputSchema: { type: 'object', properties: { jobId: { type: 'string', description: 'Job ID' } }, required: ['jobId'] } },
+    { name: 'list_talkie_jobs', description: 'List background jobs, optionally filtered by status.', inputSchema: { type: 'object', properties: { status: { type: 'string', enum: ['queued', 'running', 'completed', 'failed', 'cancelled'], description: 'Filter by status' } }, required: [] } },
+
+    // ── Data tools (work offline via direct SQLite) ──
+    { name: 'list_conversations', description: 'List all saved conversations (cassette tapes). Works offline.', inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max results (default 50)' }, offset: { type: 'number', description: 'Pagination offset (default 0)' } }, required: [] } },
+    { name: 'get_conversation', description: 'Get a full conversation by ID with messages, images, and tool activity. Works offline.', inputSchema: { type: 'object', properties: { conversationId: { type: 'string', description: 'Conversation ID' } }, required: ['conversationId'] } },
+    { name: 'create_conversation', description: 'Create a new conversation (cassette tape). Works offline.', inputSchema: { type: 'object', properties: { title: { type: 'string', description: 'Conversation title' }, id: { type: 'string', description: 'Optional custom ID' } }, required: [] } },
+    { name: 'rename_conversation', description: 'Rename an existing conversation. Works offline.', inputSchema: { type: 'object', properties: { conversationId: { type: 'string', description: 'Conversation ID' }, title: { type: 'string', description: 'New title' } }, required: ['conversationId', 'title'] } },
+    { name: 'delete_conversation', description: 'Delete a conversation permanently. Works offline.', inputSchema: { type: 'object', properties: { conversationId: { type: 'string', description: 'Conversation ID' } }, required: ['conversationId'] } },
+    { name: 'search_conversations', description: 'Full-text search across all conversations. Uses FTS5 for ranked results. Works offline.', inputSchema: { type: 'object', properties: { query: { type: 'string', description: 'Search query' }, limit: { type: 'number', description: 'Max results (default 50)' } }, required: ['query'] } },
+    { name: 'add_message', description: 'Add a message to a conversation. Works offline.', inputSchema: { type: 'object', properties: { conversationId: { type: 'string', description: 'Conversation ID' }, role: { type: 'string', enum: ['user', 'assistant'], description: 'Message role' }, content: { type: 'string', description: 'Message content' }, source: { type: 'string', description: 'Source (default "mcp")' } }, required: ['conversationId', 'role', 'content'] } },
+    { name: 'list_plans', description: 'List all plans. Works offline.', inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max results (default 50)' }, offset: { type: 'number', description: 'Pagination offset (default 0)' } }, required: [] } },
+    { name: 'get_plan', description: 'Get a plan by ID with full content. Works offline.', inputSchema: { type: 'object', properties: { planId: { type: 'string', description: 'Plan ID' } }, required: ['planId'] } },
+    { name: 'create_plan', description: 'Create a new plan with status workflow (draft > approved > in_progress > completed > archived). Works offline.', inputSchema: { type: 'object', properties: { title: { type: 'string', description: 'Plan title' }, content: { type: 'string', description: 'Plan content (markdown)' }, status: { type: 'string', enum: ['draft', 'approved', 'in_progress', 'completed', 'archived'], description: 'Initial status (default "draft")' }, conversationId: { type: 'string', description: 'Link to conversation' } }, required: ['title', 'content'] } },
+    { name: 'update_plan', description: 'Update a plan\'s title, content, or status. Works offline.', inputSchema: { type: 'object', properties: { planId: { type: 'string', description: 'Plan ID' }, title: { type: 'string', description: 'New title' }, content: { type: 'string', description: 'New content' }, status: { type: 'string', enum: ['draft', 'approved', 'in_progress', 'completed', 'archived'], description: 'New status' } }, required: ['planId'] } },
+    { name: 'delete_plan', description: 'Delete a plan permanently. Works offline.', inputSchema: { type: 'object', properties: { planId: { type: 'string', description: 'Plan ID' } }, required: ['planId'] } },
+    { name: 'get_liner_notes', description: 'Get liner notes (markdown annotations) for a conversation. Works offline.', inputSchema: { type: 'object', properties: { conversationId: { type: 'string', description: 'Conversation ID' } }, required: ['conversationId'] } },
+    { name: 'set_liner_notes', description: 'Set or clear liner notes for a conversation. Works offline.', inputSchema: { type: 'object', properties: { conversationId: { type: 'string', description: 'Conversation ID' }, linerNotes: { type: 'string', description: 'Markdown content (or null to clear)' } }, required: ['conversationId'] } },
+    { name: 'export_conversation', description: 'Export a conversation as markdown or JSON. Works offline.', inputSchema: { type: 'object', properties: { conversationId: { type: 'string', description: 'Conversation ID' }, format: { type: 'string', enum: ['markdown', 'json'], description: 'Export format (default "markdown")' } }, required: ['conversationId'] } },
+  ],
+}));
+
+// ─── Tool Call Handler ───
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
 
-  switch (name) {
-    case 'launch_talkie': {
-      const result = await launchTalkie();
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'get_talkie_status': {
-      const status = await getStatus();
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(status, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'get_transcript': {
-      const transcript = await getTranscript();
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(transcript, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'get_conversation_history': {
-      const history = await getHistory();
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(history, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'get_claude_session': {
-      const session = await getSession();
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(session, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'set_claude_session': {
-      const result = await setSession(args.sessionId);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'disconnect_claude_session': {
-      const result = await disconnectSession();
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'get_pending_message': {
-      const pending = await getPendingMessage();
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(pending, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'respond_to_talkie': {
-      const result = await respondToMessage(args.content);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'update_talkie_state': {
-      const result = await updateState(args);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'analyze_image': {
-      const result = await analyzeImage(args.dataUrl, args.fileName, args.apiKey);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'open_url': {
-      const result = await openUrl(args.url);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
-    }
-
-    case 'create_talkie_job': {
-      const result = await createJob(args.conversationId, args.prompt);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
+  try {
+    // ════════════════════════════════════════
+    // SERVER TOOLS (require Talkie running)
+    // ════════════════════════════════════════
+    switch (name) {
+      case 'launch_talkie': return jsonResult(await launchTalkie());
+      case 'get_talkie_status': return jsonResult(await serverCall(() => apiGet('/api/status')));
+      case 'get_transcript': return jsonResult(await serverCall(() => apiGet('/api/transcript')));
+      case 'get_conversation_history': return jsonResult(await serverCall(() => apiGet('/api/history')));
+      case 'get_claude_session': return jsonResult(await serverCall(() => apiGet('/api/session')));
+      case 'set_claude_session': return jsonResult(await serverCall(() => apiPost('/api/session', { sessionId: args.sessionId })));
+      case 'disconnect_claude_session': return jsonResult(await serverCall(() => apiDelete('/api/session')));
+      case 'get_pending_message': return jsonResult(await serverCall(() => apiGet('/api/pending')));
+      case 'respond_to_talkie': return jsonResult(await serverCall(() => apiPost('/api/respond', { content: args.content })));
+      case 'update_talkie_state': return jsonResult(await serverCall(() => apiPost('/api/state', args)));
+      case 'analyze_image': return jsonResult(await serverCall(() => apiPost('/api/analyze-image', { dataUrl: args.dataUrl, fileName: args.fileName, apiKey: args.apiKey })));
+      case 'open_url': return jsonResult(await serverCall(() => apiPost('/api/open-url', { url: args.url })));
+      case 'create_talkie_job': return jsonResult(await serverCall(() => apiPost('/api/jobs', { conversationId: args.conversationId, prompt: args.prompt, source: 'mcp' })));
+      case 'get_talkie_job': return jsonResult(await serverCall(() => apiGet(`/api/jobs/${args.jobId}`)));
+      case 'list_talkie_jobs': return jsonResult(await serverCall(() => apiGet(`/api/jobs${args.status ? `?status=${args.status}` : ''}`)));
     }
 
-    case 'get_talkie_job': {
-      const result = await getJobStatus(args.jobId);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
+    // ════════════════════════════════════════
+    // DATA TOOLS (direct SQLite, work offline)
+    // ════════════════════════════════════════
+    const d = await getDb();
+    if (!d) {
+      // DB unavailable — fall back to HTTP proxy
+      return jsonResult(await serverCall(async () => {
+        switch (name) {
+          case 'list_conversations': return await apiGet(`/api/conversations?limit=${args.limit || 50}&offset=${args.offset || 0}`);
+          case 'get_conversation': return await apiGet(`/api/conversations/${args.conversationId}`);
+          case 'create_conversation': return await apiPost('/api/conversations', { title: args.title || 'New conversation', ...(args.id && { id: args.id }) });
+          case 'rename_conversation': return await apiPatch(`/api/conversations/${args.conversationId}`, { title: args.title });
+          case 'delete_conversation': return await apiDelete(`/api/conversations/${args.conversationId}`);
+          case 'search_conversations': return await apiGet(`/api/search?q=${encodeURIComponent(args.query)}&limit=${args.limit || 50}`);
+          case 'add_message': return await apiPost(`/api/conversations/${args.conversationId}/messages`, { role: args.role, content: args.content, source: args.source || 'mcp' });
+          case 'list_plans': return await apiGet(`/api/plans?limit=${args.limit || 50}&offset=${args.offset || 0}`);
+          case 'get_plan': return await apiGet(`/api/plans/${args.planId}`);
+          case 'create_plan': return await apiPost('/api/plans', { title: args.title, content: args.content, status: args.status || 'draft', conversationId: args.conversationId });
+          case 'update_plan': { const b = {}; if (args.title !== undefined) b.title = args.title; if (args.content !== undefined) b.content = args.content; if (args.status !== undefined) b.status = args.status; return await apiPut(`/api/plans/${args.planId}`, b); }
+          case 'delete_plan': return await apiDelete(`/api/plans/${args.planId}`);
+          case 'get_liner_notes': return await apiGet(`/api/conversations/${args.conversationId}/liner-notes`);
+          case 'set_liner_notes': return await apiPut(`/api/conversations/${args.conversationId}/liner-notes`, { linerNotes: args.linerNotes ?? null });
+          case 'export_conversation': {
+            const conv = await apiGet(`/api/conversations/${args.conversationId}`);
+            if (conv.error) return conv;
+            return args.format === 'json' ? { format: 'json', data: conv } : { format: 'markdown', data: formatMarkdown(conv, conv.messages || [], conv.activities || []) };
+          }
+          default: throw new Error(`Unknown tool: ${name}`);
+        }
+      }));
     }
 
-    case 'list_talkie_jobs': {
-      const result = await listTalkieJobs(args.status);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2),
-          },
-        ],
-      };
+    // Direct SQLite calls
+    switch (name) {
+      case 'list_conversations': {
+        const convos = d.convos.listConversations(args.limit || 50, args.offset || 0);
+        const total = d.convos.countConversations();
+        return jsonResult({ conversations: convos, total });
+      }
+      case 'get_conversation': {
+        const conv = d.convos.getConversation(args.conversationId);
+        if (!conv) return jsonResult({ error: 'Conversation not found' });
+        const messages = d.msgs.getMessagesForConversation(args.conversationId);
+        const imageMap = d.msgs.getImagesForMessages(messages.map(m => m.id));
+        const messagesWithImages = messages.map(m => ({ ...m, images: imageMap.get(m.id) || [] }));
+        const activities = d.activities.getActivitiesForConversation(args.conversationId);
+        const linerNotes = d.convos.getLinerNotes(args.conversationId);
+        return jsonResult({ ...conv, messages: messagesWithImages, activities, liner_notes: linerNotes });
+      }
+      case 'create_conversation': {
+        const id = args.id || randomUUID();
+        const conv = d.convos.createConversation({ id, title: args.title });
+        return jsonResult(conv);
+      }
+      case 'rename_conversation': {
+        const conv = d.convos.updateConversation(args.conversationId, { title: args.title });
+        return jsonResult(conv || { error: 'Conversation not found' });
+      }
+      case 'delete_conversation': {
+        const ok = d.convos.deleteConversation(args.conversationId);
+        return jsonResult({ success: ok });
+      }
+      case 'search_conversations': {
+        const results = d.search.searchMessages(args.query, args.limit || 50);
+        return jsonResult({ results });
+      }
+      case 'add_message': {
+        const msg = d.msgs.createMessage({
+          id: randomUUID(),
+          conversationId: args.conversationId,
+          role: args.role,
+          content: args.content,
+          source: args.source || 'mcp',
+        });
+        return jsonResult(msg);
+      }
+      case 'list_plans': {
+        const plans = d.plans.listPlans(args.limit || 50, args.offset || 0);
+        return jsonResult({ plans });
+      }
+      case 'get_plan': {
+        const plan = d.plans.getPlan(args.planId);
+        return jsonResult(plan || { error: 'Plan not found' });
+      }
+      case 'create_plan': {
+        const plan = d.plans.createPlan({
+          id: randomUUID(),
+          title: args.title,
+          content: args.content,
+          status: args.status || 'draft',
+          conversationId: args.conversationId || null,
+        });
+        return jsonResult(plan);
+      }
+      case 'update_plan': {
+        const updates = {};
+        if (args.title !== undefined) updates.title = args.title;
+        if (args.content !== undefined) updates.content = args.content;
+        if (args.status !== undefined) updates.status = args.status;
+        const plan = d.plans.updatePlan(args.planId, updates);
+        return jsonResult(plan || { error: 'Plan not found' });
+      }
+      case 'delete_plan': {
+        const ok = d.plans.deletePlan(args.planId);
+        return jsonResult({ success: ok });
+      }
+      case 'get_liner_notes': {
+        const notes = d.convos.getLinerNotes(args.conversationId);
+        return jsonResult({ conversationId: args.conversationId, linerNotes: notes });
+      }
+      case 'set_liner_notes': {
+        d.convos.updateLinerNotes(args.conversationId, args.linerNotes ?? null);
+        return jsonResult({ success: true });
+      }
+      case 'export_conversation': {
+        const conv = d.convos.getConversation(args.conversationId);
+        if (!conv) return jsonResult({ error: 'Conversation not found' });
+        const messages = d.msgs.getMessagesForConversation(args.conversationId);
+        const activities = d.activities.getActivitiesForConversation(args.conversationId);
+        if (args.format === 'json') {
+          const imageMap = d.msgs.getImagesForMessages(messages.map(m => m.id));
+          const msgsWithImages = messages.map(m => ({ ...m, images: imageMap.get(m.id) || [] }));
+          return jsonResult({ format: 'json', data: { ...conv, messages: msgsWithImages, activities } });
+        }
+        return jsonResult({ format: 'markdown', data: formatMarkdown(conv, messages, activities) });
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
     }
-
-    default:
-      throw new Error(`Unknown tool: ${name}`);
+  } catch (err) {
+    return jsonResult({ error: err.message });
   }
 });
 
-// Start the server
+// ─── Start ───
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('Talkie MCP server running');
+  console.error('Talkie MCP server running (30 tools — 15 data + 15 server)');
 }
 
 main().catch(console.error);