@thoughtfree/mcp-server 0.1.0

package/bin/thoughtfree-mcp.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/client.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ThoughtFree REST API client.
+ * Lightweight HTTP wrapper — no SvelteKit dependencies.
+ */
+import type { Thought, Category, Stats, ListResponse, SearchResponse } from './types.js';
+export declare class ThoughtFreeClient {
+    private baseUrl;
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private request;
+    listThoughts(params?: {
+        cursor?: string;
+        limit?: number;
+        category?: string;
+        source?: string;
+        type?: string;
+        isStarred?: boolean;
+        isArchived?: boolean;
+    }): Promise<ListResponse<Thought>>;
+    getThought(id: string): Promise<Thought>;
+    createThought(data: {
+        content: string;
+        type?: string;
+        category?: string;
+        status?: string;
+        userTags?: string[];
+        dueDate?: string;
+        priority?: string;
+        source?: string;
+        autoClassify?: boolean;
+    }): Promise<Thought>;
+    updateThought(id: string, data: {
+        content?: string;
+        category?: string;
+        status?: string;
+        userTags?: string[];
+        isStarred?: boolean;
+        isArchived?: boolean;
+        dueDate?: string;
+        priority?: string;
+    }): Promise<Thought>;
+    searchThoughts(query: string, params?: {
+        mode?: 'semantic' | 'fulltext' | 'hybrid';
+        limit?: number;
+        threshold?: number;
+        category?: string;
+    }): Promise<SearchResponse>;
+    queryBrain(question: string): Promise<{
+        answer: string;
+    }>;
+    listCategories(): Promise<{
+        categories: Category[];
+    }>;
+    getStats(): Promise<Stats>;
+}

package/dist/client.js

@@ -0,0 +1,91 @@
+/**
+ * ThoughtFree REST API client.
+ * Lightweight HTTP wrapper — no SvelteKit dependencies.
+ */
+export class ThoughtFreeClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.apiKey = apiKey;
+    }
+    async request(path, options = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const res = await fetch(url, {
+            ...options,
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`ThoughtFree API error ${res.status}: ${body || res.statusText}`);
+        }
+        return res.json();
+    }
+    // ─── Thoughts ────────────────────────────────────────────
+    async listThoughts(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.cursor)
+            searchParams.set('cursor', params.cursor);
+        if (params?.limit)
+            searchParams.set('limit', String(params.limit));
+        if (params?.category)
+            searchParams.set('category', params.category);
+        if (params?.source)
+            searchParams.set('source', params.source);
+        if (params?.type)
+            searchParams.set('type', params.type);
+        if (params?.isStarred)
+            searchParams.set('isStarred', 'true');
+        if (params?.isArchived)
+            searchParams.set('isArchived', 'true');
+        const qs = searchParams.toString();
+        return this.request(`/api/v1/thoughts${qs ? `?${qs}` : ''}`);
+    }
+    async getThought(id) {
+        return this.request(`/api/v1/thoughts/${id}`);
+    }
+    async createThought(data) {
+        return this.request('/api/v1/thoughts', {
+            method: 'POST',
+            body: JSON.stringify(data)
+        });
+    }
+    async updateThought(id, data) {
+        return this.request(`/api/v1/thoughts/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(data)
+        });
+    }
+    // ─── Search ──────────────────────────────────────────────
+    async searchThoughts(query, params) {
+        const searchParams = new URLSearchParams({ q: query });
+        if (params?.mode)
+            searchParams.set('mode', params.mode);
+        if (params?.limit)
+            searchParams.set('limit', String(params.limit));
+        if (params?.threshold)
+            searchParams.set('threshold', String(params.threshold));
+        if (params?.category)
+            searchParams.set('category', params.category);
+        return this.request(`/api/v1/thoughts/search?${searchParams}`);
+    }
+    // ─── Query Brain (RAG) ───────────────────────────────────
+    async queryBrain(question) {
+        return this.request('/api/ai/query-thoughts', {
+            method: 'POST',
+            body: JSON.stringify({ question })
+        });
+    }
+    // ─── Categories ──────────────────────────────────────────
+    async listCategories() {
+        return this.request('/api/v1/categories');
+    }
+    // ─── Stats ───────────────────────────────────────────────
+    async getStats() {
+        return this.request('/api/v1/stats');
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ThoughtFree MCP Server
+ *
+ * Exposes your thought database as tools and resources accessible
+ * from any MCP-compatible AI agent (Claude Desktop, Cursor, VS Code, etc.).
+ */
+export declare function main(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,59 @@
+/**
+ * ThoughtFree MCP Server
+ *
+ * Exposes your thought database as tools and resources accessible
+ * from any MCP-compatible AI agent (Claude Desktop, Cursor, VS Code, etc.).
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ThoughtFreeClient } from './client.js';
+// Tools
+import { registerSearchTool } from './tools/search.js';
+import { registerCreateTool } from './tools/create.js';
+import { registerListTool } from './tools/list.js';
+import { registerGetTool } from './tools/get.js';
+import { registerUpdateTool } from './tools/update.js';
+import { registerQueryBrainTool } from './tools/query-brain.js';
+import { registerCategoriesTool } from './tools/categories.js';
+import { registerStatsTool } from './tools/stats.js';
+// Resources
+import { registerRecentResource } from './resources/recent.js';
+import { registerStarredResource } from './resources/starred.js';
+import { registerByCategoryResource } from './resources/by-category.js';
+export async function main() {
+    const apiKey = process.env.THOUGHTFREE_API_KEY;
+    const apiUrl = process.env.THOUGHTFREE_API_URL || 'https://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');
+        process.exit(1);
+    }
+    const client = new ThoughtFreeClient(apiUrl, apiKey);
+    const server = new McpServer({
+        name: 'thoughtfree',
+        version: '0.1.0'
+    });
+    // Register all tools
+    registerSearchTool(server, client);
+    registerCreateTool(server, client);
+    registerListTool(server, client);
+    registerGetTool(server, client);
+    registerUpdateTool(server, client);
+    registerQueryBrainTool(server, client);
+    registerCategoriesTool(server, client);
+    registerStatsTool(server, client);
+    // Register all resources
+    registerRecentResource(server, client);
+    registerStarredResource(server, client);
+    registerByCategoryResource(server, client);
+    // Connect via stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('ThoughtFree MCP Server running on stdio');
+    console.error(`  API URL: ${apiUrl}`);
+    console.error(`  Tools: 8 | Resources: 3`);
+}
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

package/dist/resources/by-category.d.ts

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

package/dist/resources/by-category.js

@@ -0,0 +1,36 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+export function registerByCategoryResource(server, client) {
+    server.registerResource('thoughts-by-category', new ResourceTemplate('thoughtfree://category/{categoryKey}', {
+        list: async () => {
+            try {
+                const result = await client.listCategories();
+                return {
+                    resources: result.categories
+                        .filter((c) => c.thoughtCount > 0)
+                        .map((c) => ({
+                        uri: `thoughtfree://category/${c.key}`,
+                        name: `${c.emoji} ${c.label} (${c.thoughtCount} thoughts)`
+                    }))
+                };
+            }
+            catch {
+                return { resources: [] };
+            }
+        }
+    }), {
+        title: 'Thoughts by Category',
+        description: 'Thoughts filtered by a specific category',
+        mimeType: 'application/json'
+    }, async (uri, { categoryKey }) => {
+        const result = await client.listThoughts({
+            category: categoryKey,
+            limit: 50
+        });
+        return {
+            contents: [{
+                    uri: uri.href,
+                    text: JSON.stringify(result.data, null, 2)
+                }]
+        };
+    });
+}

package/dist/resources/recent.d.ts

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

package/dist/resources/recent.js

@@ -0,0 +1,15 @@
+export function registerRecentResource(server, client) {
+    server.registerResource('recent-thoughts', 'thoughtfree://recent', {
+        title: 'Recent Thoughts',
+        description: 'Your 25 most recently captured thoughts',
+        mimeType: 'application/json'
+    }, async (uri) => {
+        const result = await client.listThoughts({ limit: 25 });
+        return {
+            contents: [{
+                    uri: uri.href,
+                    text: JSON.stringify(result.data, null, 2)
+                }]
+        };
+    });
+}

package/dist/resources/starred.d.ts

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

package/dist/resources/starred.js

@@ -0,0 +1,15 @@
+export function registerStarredResource(server, client) {
+    server.registerResource('starred-thoughts', 'thoughtfree://starred', {
+        title: 'Starred Thoughts',
+        description: 'All thoughts you\'ve marked as important',
+        mimeType: 'application/json'
+    }, async (uri) => {
+        const result = await client.listThoughts({ isStarred: true, limit: 100 });
+        return {
+            contents: [{
+                    uri: uri.href,
+                    text: JSON.stringify(result.data, null, 2)
+                }]
+        };
+    });
+}

package/dist/tools/categories.d.ts

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

package/dist/tools/categories.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export function registerCategoriesTool(server, client) {
+    server.registerTool('list_categories', {
+        title: 'List Categories',
+        description: 'List all thought categories (both predefined and custom) with emoji, label, description, and thought count per category.',
+        inputSchema: z.object({})
+    }, async () => {
+        try {
+            const result = await client.listCategories();
+            if (result.categories.length === 0) {
+                return { content: [{ type: 'text', text: 'No categories found.' }] };
+            }
+            const formatted = result.categories.map((c) => `${c.emoji} ${c.label} (${c.key}) — ${c.thoughtCount} thoughts${c.isCustom ? ' [custom]' : ''}${c.description ? `\n   ${c.description}` : ''}`).join('\n');
+            return { content: [{ type: 'text', text: `Categories:\n\n${formatted}` }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to list categories: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/create.d.ts

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

package/dist/tools/create.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export function registerCreateTool(server, client) {
+    server.registerTool('create_thought', {
+        title: 'Create Thought',
+        description: 'Capture a new thought. Thoughts can be text notes, ideas, tasks, links, etc. Auto-tagged with source "mcp" for provenance.',
+        inputSchema: z.object({
+            content: z.string().describe('The thought content'),
+            type: z.enum(['text', 'voice', 'image', 'file', 'link']).default('text').describe('Thought type'),
+            category: z.string().optional().describe('Category (e.g., thought, idea, insight, bug, feature)'),
+            userTags: z.array(z.string()).optional().describe('Tags to attach'),
+            dueDate: z.string().optional().describe('Due date in YYYY-MM-DD format (for tasks)'),
+            priority: z.enum(['high', 'medium', 'low']).optional().describe('Priority level'),
+            autoClassify: z.boolean().default(true).describe('Let AI classify the thought automatically')
+        })
+    }, async ({ content, type, category, userTags, dueDate, priority, autoClassify }) => {
+        try {
+            const result = await client.createThought({
+                content,
+                type,
+                category,
+                userTags,
+                dueDate,
+                priority,
+                source: 'mcp',
+                autoClassify
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Thought created successfully.\nID: ${result.id}\nType: ${result.type}\nCategory: ${result.category || 'uncategorized'}${result.dueDate ? `\nDue: ${result.dueDate}` : ''}${result.priority ? `\nPriority: ${result.priority}` : ''}\nCreated: ${result.createdAt}`
+                    }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to create thought: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/get.d.ts

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

package/dist/tools/get.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export function registerGetTool(server, client) {
+    server.registerTool('get_thought', {
+        title: 'Get Thought',
+        description: 'Fetch a specific thought by its server ID. Returns the full thought object with all fields.',
+        inputSchema: z.object({
+            id: z.string().describe('The thought\'s server UUID')
+        })
+    }, async ({ id }) => {
+        try {
+            const t = await client.getThought(id);
+            const lines = [
+                `Content: ${t.content}`,
+                `ID: ${t.id}`,
+                `Type: ${t.type}`,
+                `Category: ${t.category || 'uncategorized'}`,
+                `Status: ${t.status || 'none'}`,
+                `Starred: ${t.isStarred ? 'yes' : 'no'}`,
+                `Archived: ${t.isArchived ? 'yes' : 'no'}`,
+                t.userTags.length ? `Tags: ${t.userTags.join(', ')}` : null,
+                t.dueDate ? `Due: ${t.dueDate}` : null,
+                t.priority ? `Priority: ${t.priority}` : null,
+                t.completedAt ? `Completed: ${t.completedAt}` : null,
+                t.source ? `Source: ${t.source}` : null,
+                `Created: ${t.createdAt}`,
+                `Updated: ${t.updatedAt}`
+            ].filter(Boolean).join('\n');
+            return { content: [{ type: 'text', text: lines }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to get thought: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/list.d.ts

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

package/dist/tools/list.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export function registerListTool(server, client) {
+    server.registerTool('list_thoughts', {
+        title: 'List Thoughts',
+        description: 'Browse thoughts with optional filters and pagination. Returns newest first.',
+        inputSchema: z.object({
+            category: z.string().optional().describe('Filter by category'),
+            type: z.string().optional().describe('Filter by type (text, voice, image, file, link)'),
+            isStarred: z.boolean().optional().describe('Only show starred thoughts'),
+            isArchived: z.boolean().optional().describe('Only show archived thoughts'),
+            limit: z.number().min(1).max(100).default(20).describe('Number of thoughts to return'),
+            cursor: z.string().optional().describe('Pagination cursor from previous response')
+        })
+    }, async ({ category, type, isStarred, isArchived, limit, cursor }) => {
+        try {
+            const result = await client.listThoughts({ category, type, isStarred, isArchived, limit, cursor });
+            if (result.data.length === 0) {
+                return { content: [{ type: 'text', text: 'No thoughts found matching the filters.' }] };
+            }
+            const formatted = result.data.map((t, i) => `${i + 1}. ${t.category ? `[${t.category}] ` : ''}${t.isStarred ? '★ ' : ''}${t.content.slice(0, 200)}${t.content.length > 200 ? '...' : ''}\n   ID: ${t.id} | Type: ${t.type} | Created: ${t.createdAt}${t.userTags.length ? ` | Tags: ${t.userTags.join(', ')}` : ''}`).join('\n\n');
+            let text = `Showing ${result.data.length} thoughts:\n\n${formatted}`;
+            if (result.hasMore && result.cursor) {
+                text += `\n\n--- More results available. Use cursor: "${result.cursor}" ---`;
+            }
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to list thoughts: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/query-brain.d.ts

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

package/dist/tools/query-brain.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export function registerQueryBrainTool(server, client) {
+    server.registerTool('query_brain', {
+        title: 'Query Brain',
+        description: 'Ask a natural language question about your thoughts. Uses semantic search to find relevant context and an AI model to synthesize an answer based on your thought history.',
+        inputSchema: z.object({
+            question: z.string().describe('Your question about your thoughts')
+        })
+    }, async ({ question }) => {
+        try {
+            const result = await client.queryBrain(question);
+            return { content: [{ type: 'text', text: result.answer }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Query failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/search.d.ts

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

package/dist/tools/search.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export function registerSearchTool(server, client) {
+    server.registerTool('search_thoughts', {
+        title: 'Search Thoughts',
+        description: 'Search your thought database using semantic (AI-powered meaning), full-text, or hybrid search. Returns the most relevant thoughts with similarity scores.',
+        inputSchema: z.object({
+            query: z.string().describe('The search query'),
+            mode: z.enum(['semantic', 'fulltext', 'hybrid']).default('hybrid').describe('Search mode: semantic (meaning), fulltext (exact terms), or hybrid (both)'),
+            limit: z.number().min(1).max(50).default(10).describe('Maximum number of results'),
+            category: z.string().optional().describe('Filter by category')
+        })
+    }, async ({ query, mode, limit, category }) => {
+        try {
+            const result = await client.searchThoughts(query, { mode, limit, category });
+            if (result.data.length === 0) {
+                return { content: [{ type: 'text', text: `No thoughts found matching "${query}".` }] };
+            }
+            const formatted = result.data.map((t, i) => `${i + 1}. [${t.matchType}] (score: ${t.score.toFixed(2)}) ${t.category ? `[${t.category}] ` : ''}${t.content.slice(0, 200)}${t.content.length > 200 ? '...' : ''}\n   ID: ${t.id} | Created: ${t.createdAt}`).join('\n\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Found ${result.total} results for "${query}" (mode: ${result.mode}):\n\n${formatted}`
+                    }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Search failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/stats.d.ts

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

package/dist/tools/stats.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export function registerStatsTool(server, client) {
+    server.registerTool('get_stats', {
+        title: 'Get Stats',
+        description: 'Get summary statistics about your thought database: total count, category/type breakdown, starred/archived counts, date range, and embedding coverage.',
+        inputSchema: z.object({})
+    }, async () => {
+        try {
+            const s = await client.getStats();
+            const catBreakdown = Object.entries(s.byCategory)
+                .sort(([, a], [, b]) => b - a)
+                .map(([k, v]) => `  ${k}: ${v}`)
+                .join('\n');
+            const typeBreakdown = Object.entries(s.byType)
+                .sort(([, a], [, b]) => b - a)
+                .map(([k, v]) => `  ${k}: ${v}`)
+                .join('\n');
+            const lines = [
+                `Total thoughts: ${s.totalThoughts}`,
+                `Starred: ${s.starred}`,
+                `Archived: ${s.archived}`,
+                `With due date: ${s.withDueDate}`,
+                `Embedding coverage: ${s.embeddingCoverage}%`,
+                s.oldestThought ? `Oldest: ${s.oldestThought}` : null,
+                s.newestThought ? `Newest: ${s.newestThought}` : null,
+                '',
+                'By category:',
+                catBreakdown || '  (none)',
+                '',
+                'By type:',
+                typeBreakdown || '  (none)'
+            ].filter((l) => l !== null).join('\n');
+            return { content: [{ type: 'text', text: lines }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to get stats: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/tools/update.d.ts

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

package/dist/tools/update.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export function registerUpdateTool(server, client) {
+    server.registerTool('update_thought', {
+        title: 'Update Thought',
+        description: 'Update an existing thought\'s content, category, tags, priority, starred status, or due date. All fields are optional — only provided fields are changed.',
+        inputSchema: z.object({
+            id: z.string().describe('The thought\'s server UUID'),
+            content: z.string().optional().describe('New content'),
+            category: z.string().optional().describe('New category'),
+            status: z.string().optional().describe('New status'),
+            userTags: z.array(z.string()).optional().describe('New tags (replaces existing)'),
+            isStarred: z.boolean().optional().describe('Star or unstar'),
+            isArchived: z.boolean().optional().describe('Archive or unarchive'),
+            dueDate: z.string().optional().describe('New due date (YYYY-MM-DD) or empty to clear'),
+            priority: z.enum(['high', 'medium', 'low']).optional().describe('New priority')
+        })
+    }, async ({ id, ...updates }) => {
+        try {
+            const t = await client.updateThought(id, updates);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Thought updated successfully.\nID: ${t.id}\nContent: ${t.content.slice(0, 100)}${t.content.length > 100 ? '...' : ''}\nCategory: ${t.category || 'uncategorized'}\nUpdated: ${t.updatedAt}`
+                    }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Failed to update thought: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,59 @@
+export interface Thought {
+    id: string;
+    clientId: string;
+    content: string;
+    type: string;
+    category: string | null;
+    status: string | null;
+    source: string | null;
+    userTags: string[];
+    isStarred: boolean;
+    isArchived: boolean;
+    dueDate: string | null;
+    priority: string | null;
+    completedAt: string | null;
+    attachments: unknown[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SearchResult {
+    id: string;
+    clientId: string;
+    content: string;
+    type: string;
+    category: string | null;
+    userTags: string[];
+    createdAt: string;
+    score: number;
+    matchType: 'semantic' | 'fulltext';
+}
+export interface Category {
+    key: string;
+    emoji: string;
+    label: string;
+    description: string | null;
+    isCustom: boolean;
+    thoughtCount: number;
+}
+export interface Stats {
+    totalThoughts: number;
+    byCategory: Record<string, number>;
+    byType: Record<string, number>;
+    starred: number;
+    archived: number;
+    withDueDate: number;
+    embeddingCoverage: number;
+    oldestThought: string | null;
+    newestThought: string | null;
+}
+export interface ListResponse<T> {
+    data: T[];
+    cursor: string | null;
+    hasMore: boolean;
+}
+export interface SearchResponse {
+    data: SearchResult[];
+    query: string;
+    mode: string;
+    total: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@thoughtfree/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for ThoughtFree — access your thought database from any AI agent",
+  "type": "module",
+  "bin": {
+    "thoughtfree-mcp": "./bin/thoughtfree-mcp.mjs"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "tsc"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "thoughtfree",
+    "ai",
+    "thoughts",
+    "claude",
+    "cursor"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/WholenessMedia/thoughtfree.git",
+    "directory": "packages/mcp-server"
+  },
+  "homepage": "https://thoughtfree.io",
+  "bugs": {
+    "url": "https://github.com/WholenessMedia/thoughtfree/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}