@thoughtfree/mcp-server 0.2.0 → 0.3.0

package/dist/client.d.ts

@@ -2,7 +2,7 @@
  * ThoughtFree REST API client.
  * Lightweight HTTP wrapper — no SvelteKit dependencies.
  */
-import type { Thought, Category, Stats, ListResponse, SearchResponse } from './types.js';
+import type { Thought, Category, Stats, ListResponse, SearchResponse, Pipeline, PipelineRun, PipelineRunResult, WeeklyInsight, TranscribeResult, ResearchResult } from './types.js';
 export declare class ThoughtFreeClient {
     private baseUrl;
     private apiKey;
@@ -17,6 +17,7 @@ export declare class ThoughtFreeClient {
         isStarred?: boolean;
         isArchived?: boolean;
         deleted?: boolean;
+        parentThoughtId?: string;
     }): Promise<ListResponse<Thought>>;
     getThought(id: string): Promise<Thought>;
     createThought(data: {
@@ -29,6 +30,7 @@ export declare class ThoughtFreeClient {
         priority?: string;
         source?: string;
         autoClassify?: boolean;
+        parentThoughtId?: string;
     }): Promise<Thought>;
     updateThought(id: string, data: {
         content?: string;
@@ -62,4 +64,22 @@ export declare class ThoughtFreeClient {
         categories: Category[];
     }>;
     getStats(): Promise<Stats>;
+    listPipelines(): Promise<{
+        pipelines: Pipeline[];
+    }>;
+    runPipeline(id: string): Promise<PipelineRunResult>;
+    getPipelineRuns(id: string, params?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        runs: PipelineRun[];
+        nextCursor: string | null;
+    }>;
+    getWeeklyInsights(thoughts: {
+        content: string;
+        createdAt: string;
+        tags?: string[];
+    }[]): Promise<WeeklyInsight>;
+    transcribeYoutube(url: string): Promise<TranscribeResult>;
+    researchAnalyze(question: string, transcript: string, title?: string): Promise<ResearchResult>;
 }

package/dist/client.js

@@ -44,6 +44,8 @@ export class ThoughtFreeClient {
             searchParams.set('isArchived', 'true');
         if (params?.deleted)
             searchParams.set('deleted', 'true');
+        if (params?.parentThoughtId)
+            searchParams.set('parentThoughtId', params.parentThoughtId);
         const qs = searchParams.toString();
         return this.request(`/api/v1/thoughts${qs ? `?${qs}` : ''}`);
     }
@@ -100,4 +102,42 @@ export class ThoughtFreeClient {
     async getStats() {
         return this.request('/api/v1/stats');
     }
+    // ─── Pipelines ────────────────────────────────────────────
+    async listPipelines() {
+        return this.request('/api/v1/pipelines');
+    }
+    async runPipeline(id) {
+        return this.request(`/api/v1/pipelines/${id}/run`, {
+            method: 'POST'
+        });
+    }
+    async getPipelineRuns(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params?.limit)
+            searchParams.set('limit', String(params.limit));
+        if (params?.cursor)
+            searchParams.set('cursor', params.cursor);
+        const qs = searchParams.toString();
+        return this.request(`/api/v1/pipelines/${id}/runs${qs ? `?${qs}` : ''}`);
+    }
+    // ─── Weekly Insights ─────────────────────────────────────
+    async getWeeklyInsights(thoughts) {
+        return this.request('/api/ai/weekly-insights', {
+            method: 'POST',
+            body: JSON.stringify({ thoughts })
+        });
+    }
+    // ─── Research ────────────────────────────────────────────
+    async transcribeYoutube(url) {
+        return this.request('/api/research/transcribe-youtube', {
+            method: 'POST',
+            body: JSON.stringify({ url })
+        });
+    }
+    async researchAnalyze(question, transcript, title) {
+        return this.request('/api/research/analyze', {
+            method: 'POST',
+            body: JSON.stringify({ question, transcript, title })
+        });
+    }
 }

package/dist/index.js

@@ -10,7 +10,7 @@ import { ThoughtFreeClient } from './client.js';
 import { registerAllMcpCapabilities } from './register.js';
 export async function main() {
     const apiKey = process.env.THOUGHTFREE_API_KEY;
-    const apiUrl = process.env.THOUGHTFREE_API_URL || 'https://thoughtfree.io';
+    const apiUrl = process.env.THOUGHTFREE_API_URL || 'https://app.thoughtfree.io';
     if (!apiKey) {
         console.error('Error: THOUGHTFREE_API_KEY environment variable is required.');
         console.error('Create an API key at: ThoughtFree > Settings > API Keys');
@@ -27,7 +27,7 @@ export async function main() {
     await server.connect(transport);
     console.error('ThoughtFree MCP Server running on stdio');
     console.error(`  API URL: ${apiUrl}`);
-    console.error(`  Tools: 10 | Resources: 3`);
+    console.error(`  Tools: 18 | Resources: 3 | Prompts: 5`);
 }
 main().catch((err) => {
     console.error('Fatal error:', err);

package/dist/prompts/daily-capture.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerDailyCapturePrompt(server: McpServer): void;

package/dist/prompts/daily-capture.js

@@ -0,0 +1,20 @@
+export function registerDailyCapturePrompt(server) {
+    server.prompt('daily_capture', 'Morning brain dump: conversationally capture scattered thoughts, ideas, and tasks, then organize them.', () => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `I'd like to do a brain dump. Help me capture what's on my mind.
+
+Ask me what I'm thinking about, then for each distinct thought, idea, or task I share:
+1. Use create_thought to save it with an appropriate type and category.
+2. If something sounds like a task, set a dueDate and priority.
+3. After I'm done capturing, give me a quick summary of what we captured and suggest any categories or tags to clean up.
+
+Start by asking me: "What's on your mind?"`
+                }
+            }
+        ]
+    }));
+}

package/dist/prompts/organize-inbox.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerOrganizeInboxPrompt(server: McpServer): void;

package/dist/prompts/organize-inbox.js

@@ -0,0 +1,21 @@
+export function registerOrganizeInboxPrompt(server) {
+    server.prompt('organize_inbox', 'Triage uncategorized thoughts: review, categorize, star important ones, and archive or delete stale items.', () => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Help me organize my thought inbox.
+
+1. Use list_categories to see what categories are available.
+2. Use list_thoughts with limit 20 to find my recent uncategorized thoughts.
+3. For each thought, suggest a category. Group similar thoughts together.
+4. Present your suggestions and wait for my approval before making changes.
+5. Use update_thought to apply the categories I approve.
+6. Star anything that looks important, and ask if I want to archive anything old or irrelevant.
+7. Give me a summary of what we organized when we're done.`
+                }
+            }
+        ]
+    }));
+}

package/dist/prompts/pipeline-status.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerPipelineStatusPrompt(server: McpServer): void;

package/dist/prompts/pipeline-status.js

@@ -0,0 +1,18 @@
+export function registerPipelineStatusPrompt(server) {
+    server.prompt('pipeline_status', 'Check all your automation pipelines and their recent run status at a glance.', () => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Check on all my automation pipelines.
+
+1. Use list_pipelines to get all my pipelines.
+2. For each active pipeline, use get_pipeline_runs with limit 3 to check recent run status.
+3. Give me a health summary: which pipelines are running fine, which have recent failures, and which haven't run recently.
+4. If any pipeline has errors, suggest what might be wrong and whether I should re-run it.`
+                }
+            }
+        ]
+    }));
+}

package/dist/prompts/research-video.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerResearchVideoPrompt(server: McpServer): void;

package/dist/prompts/research-video.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export function registerResearchVideoPrompt(server) {
+    server.prompt('research_video', 'Research a YouTube video: transcribe it, analyze the content, and save key insights as thoughts.', { url: z.string().describe('YouTube video URL') }, ({ url }) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Research this YouTube video for me: ${url}
+
+Here's what I'd like:
+1. Use transcribe_youtube to get the transcript.
+2. Use research_analyze to summarize the main points and key takeaways.
+3. Save the top 3-5 insights as individual thoughts using create_thought with category "insight" and the video title in tags.
+4. Ask me if I have any follow-up questions about the video content.`
+                }
+            }
+        ]
+    }));
+}

package/dist/prompts/weekly-review.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerWeeklyReviewPrompt(server: McpServer): void;

package/dist/prompts/weekly-review.js

@@ -0,0 +1,19 @@
+export function registerWeeklyReviewPrompt(server) {
+    server.prompt('weekly_review', 'Guided weekly reflection: review patterns in your thoughts, celebrate wins, and set intentions for next week.', () => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Help me review my week. Here's what I'd like you to do:
+
+1. Use get_stats to see my overall activity this week.
+2. Use get_weekly_insights with period "this_week" to analyze my thought patterns.
+3. Summarize the key themes, what's going well, and what I should watch out for.
+4. If there are any actionable takeaways, create a thought to capture them using create_thought with category "insight".
+5. End with one question to help me reflect deeper.`
+                }
+            }
+        ]
+    }));
+}

package/dist/register.js

@@ -15,11 +15,22 @@ import { registerRestoreTool } from './tools/restore.js';
 import { registerQueryBrainTool } from './tools/query-brain.js';
 import { registerCategoriesTool } from './tools/categories.js';
 import { registerStatsTool } from './tools/stats.js';
+import { registerWeeklyInsightsTool } from './tools/weekly-insights.js';
+import { registerPipelineTools } from './tools/pipelines.js';
+import { registerCommentTools } from './tools/comments.js';
+import { registerResearchTools } from './tools/research.js';
 // Resources
 import { registerRecentResource } from './resources/recent.js';
 import { registerStarredResource } from './resources/starred.js';
 import { registerByCategoryResource } from './resources/by-category.js';
+// Prompts
+import { registerWeeklyReviewPrompt } from './prompts/weekly-review.js';
+import { registerDailyCapturePrompt } from './prompts/daily-capture.js';
+import { registerResearchVideoPrompt } from './prompts/research-video.js';
+import { registerOrganizeInboxPrompt } from './prompts/organize-inbox.js';
+import { registerPipelineStatusPrompt } from './prompts/pipeline-status.js';
 export function registerAllMcpCapabilities(server, client) {
+    // Core tools (10)
     registerSearchTool(server, client);
     registerCreateTool(server, client);
     registerListTool(server, client);
@@ -30,7 +41,19 @@ export function registerAllMcpCapabilities(server, client) {
     registerQueryBrainTool(server, client);
     registerCategoriesTool(server, client);
     registerStatsTool(server, client);
+    // Expanded tools (8)
+    registerWeeklyInsightsTool(server, client);
+    registerPipelineTools(server, client); // 3 tools
+    registerCommentTools(server, client); // 2 tools
+    registerResearchTools(server, client); // 2 tools
+    // Resources (3)
     registerRecentResource(server, client);
     registerStarredResource(server, client);
     registerByCategoryResource(server, client);
+    // Prompts (5)
+    registerWeeklyReviewPrompt(server);
+    registerDailyCapturePrompt(server);
+    registerResearchVideoPrompt(server);
+    registerOrganizeInboxPrompt(server);
+    registerPipelineStatusPrompt(server);
 }

package/dist/tools/comments.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ThoughtFreeClient } from '../client.js';
+export declare function registerCommentTools(server: McpServer, client: ThoughtFreeClient): void;

package/dist/tools/comments.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export function registerCommentTools(server, client) {
+    server.registerTool('add_comment', {
+        title: 'Add Comment',
+        description: 'Add a comment (sub-thought) to an existing thought. Comments are threaded replies that add context or notes to a parent thought.',
+        inputSchema: z.object({
+            parentThoughtId: z.string().describe('The ID of the thought to comment on'),
+            content: z.string().describe('The comment text')
+        })
+    }, async ({ parentThoughtId, content }) => {
+        try {
+            const result = await client.createThought({
+                content,
+                type: 'text',
+                source: 'mcp',
+                parentThoughtId
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Comment added to thought ${parentThoughtId}.\nComment ID: ${result.id}\nCreated: ${result.createdAt}`
+                    }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to add comment: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    server.registerTool('get_comments', {
+        title: 'Get Comments',
+        description: 'List all comments (sub-thoughts) on a parent thought. Returns comments sorted by creation time.',
+        inputSchema: z.object({
+            parentThoughtId: z.string().describe('The ID of the parent thought')
+        })
+    }, async ({ parentThoughtId }) => {
+        try {
+            const result = await client.listThoughts({ parentThoughtId, limit: 100 });
+            if (result.data.length === 0) {
+                return { content: [{ type: 'text', text: 'No comments on this thought.' }] };
+            }
+            const formatted = result.data.map((c, i) => `${i + 1}. ${c.content.slice(0, 300)}${c.content.length > 300 ? '...' : ''}\n   ID: ${c.id} | Created: ${c.createdAt}`).join('\n\n');
+            return { content: [{ type: 'text', text: `${result.data.length} comment(s):\n\n${formatted}` }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to get comments: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/pipelines.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ThoughtFreeClient } from '../client.js';
+export declare function registerPipelineTools(server: McpServer, client: ThoughtFreeClient): void;

package/dist/tools/pipelines.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export function registerPipelineTools(server, client) {
+    server.registerTool('list_pipelines', {
+        title: 'List Pipelines',
+        description: 'List your automation pipelines. Pipelines run scheduled actions on categories of thoughts (summarize, digest, research, export). Requires Pro plan.',
+        inputSchema: z.object({})
+    }, async () => {
+        try {
+            const { pipelines } = await client.listPipelines();
+            if (pipelines.length === 0) {
+                return { content: [{ type: 'text', text: 'No pipelines configured. Create one in ThoughtFree Settings > Automations.' }] };
+            }
+            const formatted = pipelines.map((p, i) => `${i + 1}. **${p.name}** ${p.isActive ? '✓ Active' : '✗ Inactive'}\n   Action: ${p.action} | Category: ${p.category}\n   Last run: ${p.lastRunAt ? `${p.lastRunAt} (${p.lastRunStatus})` : 'Never'}\n   ID: ${p.id}`).join('\n\n');
+            return { content: [{ type: 'text', text: `${pipelines.length} pipeline(s):\n\n${formatted}` }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to list pipelines: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    server.registerTool('run_pipeline', {
+        title: 'Run Pipeline',
+        description: 'Manually trigger an automation pipeline. The pipeline must be active. Returns the run status and results. Requires Pro plan.',
+        inputSchema: z.object({
+            pipelineId: z.string().describe('The pipeline ID to run (use list_pipelines to find IDs)')
+        })
+    }, async ({ pipelineId }) => {
+        try {
+            const result = await client.runPipeline(pipelineId);
+            const parts = [
+                `Pipeline run ${result.status === 'success' ? 'completed successfully' : 'failed'}.`,
+                `Run ID: ${result.runId}`,
+                `Status: ${result.status}`,
+                `Processed: ${result.processedCount} thought(s)`,
+                `Duration: ${result.durationMs}ms`
+            ];
+            if (result.result) {
+                parts.push(`\nResult:\n${result.result}`);
+            }
+            if (result.error) {
+                parts.push(`\nError: ${result.error}`);
+            }
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to run pipeline: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    server.registerTool('get_pipeline_runs', {
+        title: 'Pipeline Run History',
+        description: 'Get recent execution history for a pipeline. Shows status, duration, and results of past runs. Requires Pro plan.',
+        inputSchema: z.object({
+            pipelineId: z.string().describe('The pipeline ID'),
+            limit: z.number().min(1).max(50).default(10).describe('Number of runs to return')
+        })
+    }, async ({ pipelineId, limit }) => {
+        try {
+            const { runs } = await client.getPipelineRuns(pipelineId, { limit });
+            if (runs.length === 0) {
+                return { content: [{ type: 'text', text: 'No runs found for this pipeline.' }] };
+            }
+            const formatted = runs.map((r, i) => {
+                const status = r.status === 'completed' ? '✓' : r.status === 'failed' ? '✗' : '…';
+                const duration = r.durationMs ? `${r.durationMs}ms` : 'N/A';
+                return `${i + 1}. ${status} ${r.status} | ${r.triggeredBy} | ${r.processedCount ?? 0} thoughts | ${duration} | ${r.startedAt || r.createdAt}${r.error ? `\n   Error: ${r.error}` : ''}`;
+            }).join('\n');
+            return { content: [{ type: 'text', text: `Recent runs:\n\n${formatted}` }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to get pipeline runs: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/research.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ThoughtFreeClient } from '../client.js';
+export declare function registerResearchTools(server: McpServer, client: ThoughtFreeClient): void;

package/dist/tools/research.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export function registerResearchTools(server, client) {
+    server.registerTool('transcribe_youtube', {
+        title: 'Transcribe YouTube',
+        description: 'Extract the transcript (captions) from a YouTube video. Returns the video title and full transcript text. Use this before research_analyze to study a video.',
+        inputSchema: z.object({
+            url: z.string().describe('YouTube video URL (e.g., https://www.youtube.com/watch?v=...)')
+        })
+    }, async ({ url }) => {
+        try {
+            const result = await client.transcribeYoutube(url);
+            if (!result.transcript) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Could not transcribe "${result.title}" (${result.videoId}): ${result.error || 'No captions available'}`
+                        }]
+                };
+            }
+            const preview = result.transcript.length > 500
+                ? result.transcript.slice(0, 500) + '...'
+                : result.transcript;
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**${result.title}** (${result.videoId})\nLanguage: ${result.language || 'unknown'}\nTranscript length: ${result.transcript.length} characters\n\n${preview}\n\n---\nFull transcript available. Use research_analyze to ask questions about this video.`
+                    }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to transcribe video: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    server.registerTool('research_analyze', {
+        title: 'Research Analyze',
+        description: 'Ask a question about a transcript or text. Uses AI to analyze the content and return a detailed answer with key points and follow-up questions. Great for studying YouTube transcripts, articles, or any long text.',
+        inputSchema: z.object({
+            question: z.string().describe('The question to answer about the content'),
+            transcript: z.string().describe('The transcript or text to analyze'),
+            title: z.string().optional().describe('Title of the source material')
+        })
+    }, async ({ question, transcript, title }) => {
+        try {
+            const result = await client.researchAnalyze(question, transcript, title);
+            const parts = [
+                `## Answer\n${result.answer}\n`
+            ];
+            if (result.keyPoints.length > 0) {
+                parts.push(`## Key Points\n${result.keyPoints.map(p => `- ${p}`).join('\n')}\n`);
+            }
+            if (result.suggestedQuestions.length > 0) {
+                parts.push(`## Follow-up Questions\n${result.suggestedQuestions.map(q => `- ${q}`).join('\n')}`);
+            }
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Research analysis failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/weekly-insights.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ThoughtFreeClient } from '../client.js';
+export declare function registerWeeklyInsightsTool(server: McpServer, client: ThoughtFreeClient): void;

package/dist/tools/weekly-insights.js

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+export function registerWeeklyInsightsTool(server, client) {
+    server.registerTool('get_weekly_insights', {
+        title: 'Weekly Insights',
+        description: 'Get AI-analyzed patterns, themes, and growth areas from your recent thoughts. Identifies recurring themes, emotional tone, concerns, and offers a gentle suggestion. Requires Pro plan.',
+        inputSchema: z.object({
+            period: z.enum(['this_week', 'last_week']).default('this_week').describe('Which week to analyze')
+        })
+    }, async ({ period }) => {
+        try {
+            // Calculate date range
+            const now = new Date();
+            const dayOfWeek = now.getDay(); // 0=Sun, 1=Mon, ...
+            const startOfThisWeek = new Date(now);
+            startOfThisWeek.setDate(now.getDate() - dayOfWeek);
+            startOfThisWeek.setHours(0, 0, 0, 0);
+            let from;
+            let to;
+            if (period === 'last_week') {
+                to = new Date(startOfThisWeek);
+                from = new Date(startOfThisWeek);
+                from.setDate(from.getDate() - 7);
+            }
+            else {
+                from = startOfThisWeek;
+                to = now;
+            }
+            // Fetch thoughts in the date range
+            const result = await client.listThoughts({ limit: 100 });
+            const thoughts = result.data
+                .filter(t => {
+                const created = new Date(t.createdAt);
+                return created >= from && created <= to;
+            })
+                .map(t => ({
+                content: t.content,
+                createdAt: t.createdAt,
+                tags: t.userTags
+            }));
+            if (thoughts.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `No thoughts found for ${period === 'last_week' ? 'last week' : 'this week'}. Capture some thoughts first!`
+                        }]
+                };
+            }
+            const insight = await client.getWeeklyInsights(thoughts);
+            const parts = [
+                `## Weekly Insights (${period === 'last_week' ? 'Last Week' : 'This Week'})`,
+                `**${thoughts.length} thoughts analyzed**\n`,
+                `### Summary\n${insight.summary}\n`,
+                `### Themes\n${insight.themes.map(t => `- ${t}`).join('\n')}\n`
+            ];
+            if (insight.patterns.emotionalTone) {
+                parts.push(`### Emotional Tone\n${insight.patterns.emotionalTone}${insight.patterns.emotionalScore ? ` (${insight.patterns.emotionalScore}/5)` : ''}\n`);
+            }
+            if (insight.concerns.length > 0) {
+                parts.push(`### Concerns\n${insight.concerns.map(c => `- ${c}`).join('\n')}\n`);
+            }
+            if (insight.growth.length > 0) {
+                parts.push(`### Growth\n${insight.growth.map(g => `- ${g}`).join('\n')}\n`);
+            }
+            parts.push(`### Suggestion\n${insight.suggestion}`);
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to get weekly insights: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/types.d.ts

@@ -13,6 +13,7 @@ export interface Thought {
     priority: string | null;
     completedAt: string | null;
     attachments: unknown[];
+    parentThoughtId: string | null;
     createdAt: string;
     updatedAt: string;
     deletedAt?: string | null;
@@ -58,3 +59,63 @@ export interface SearchResponse {
     mode: string;
     total: number;
 }
+export interface Pipeline {
+    id: string;
+    name: string;
+    description: string | null;
+    category: string;
+    action: string;
+    config: Record<string, unknown>;
+    isActive: boolean;
+    lastRunAt: string | null;
+    lastRunStatus: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PipelineRun {
+    id: string;
+    pipelineId: string;
+    status: string;
+    triggeredBy: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    durationMs: number | null;
+    processedCount: number | null;
+    result: string | null;
+    resultMetadata: Record<string, unknown>;
+    error: string | null;
+    createdAt: string;
+}
+export interface PipelineRunResult {
+    runId: string;
+    status: string;
+    processedCount: number;
+    result: string | null;
+    error: string | null;
+    durationMs: number;
+}
+export interface WeeklyInsight {
+    summary: string;
+    themes: string[];
+    patterns: {
+        timeOfDay?: string | null;
+        emotionalTone?: string | null;
+        emotionalScore?: number | null;
+        topCategories?: string[];
+    };
+    concerns: string[];
+    growth: string[];
+    suggestion: string;
+}
+export interface TranscribeResult {
+    videoId: string;
+    title: string;
+    transcript: string | null;
+    language?: string;
+    error?: string;
+}
+export interface ResearchResult {
+    answer: string;
+    keyPoints: string[];
+    suggestedQuestions: string[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thoughtfree/mcp-server",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "MCP server for ThoughtFree — access your thought database from any AI agent",
   "type": "module",
   "bin": {