@vibetasks/mcp-server 0.1.0

package/scripts/install.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function install() {
+  try {
+    // Determine Claude Code config location
+    const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    const claudeConfigDir = path.join(configHome, 'claude-code');
+    const claudeConfigPath = path.join(claudeConfigDir, 'config.json');
+
+    // Get absolute path to MCP server
+    const mcpServerPath = path.resolve(__dirname, '..', 'dist', 'index.js');
+
+    // Read Supabase credentials from web app .env
+    const webEnvPath = path.resolve(__dirname, '..', '..', '..', 'apps', 'web', '.env.local');
+    let supabaseUrl = 'https://cbkkztbcoitrfcleghfd.supabase.co';
+    let supabaseKey = '';
+
+    try {
+      const envContent = await fs.readFile(webEnvPath, 'utf-8');
+      const urlMatch = envContent.match(/NEXT_PUBLIC_SUPABASE_URL=(.+)/);
+      const keyMatch = envContent.match(/NEXT_PUBLIC_SUPABASE_ANON_KEY=(.+)/);
+
+      if (urlMatch) supabaseUrl = urlMatch[1].trim();
+      if (keyMatch) supabaseKey = keyMatch[1].trim();
+    } catch (error) {
+      console.warn('⚠️  Could not read .env.local, using defaults');
+    }
+
+    // Read existing config or create new
+    let config = {};
+    try {
+      const existingConfig = await fs.readFile(claudeConfigPath, 'utf-8');
+      config = JSON.parse(existingConfig);
+    } catch (error) {
+      // Config doesn't exist, will create new
+      await fs.mkdir(claudeConfigDir, { recursive: true });
+    }
+
+    // Add TaskFlow MCP server
+    if (!config.mcpServers) config.mcpServers = {};
+
+    config.mcpServers.taskflow = {
+      command: 'node',
+      args: [mcpServerPath],
+      env: {
+        TASKFLOW_SUPABASE_URL: supabaseUrl,
+        TASKFLOW_SUPABASE_KEY: supabaseKey
+      }
+    };
+
+    // Add hooks
+    if (!config.hooks) config.hooks = {};
+
+    config.hooks.SessionStart = config.hooks.SessionStart || [];
+    config.hooks.Stop = config.hooks.Stop || [];
+
+    // Add SessionStart hook if not already present
+    const sessionStartExists = config.hooks.SessionStart.some(
+      h => h.command === 'node' && h.args?.[0] === mcpServerPath
+    );
+
+    if (!sessionStartExists) {
+      config.hooks.SessionStart.push({
+        type: 'command',
+        command: 'node',
+        args: [mcpServerPath],
+        env: {
+          CLAUDE_HOOK_TYPE: 'SessionStart',
+          TASKFLOW_SUPABASE_URL: supabaseUrl
+        }
+      });
+    }
+
+    // Add SessionEnd (Stop) hook if not already present
+    const sessionEndExists = config.hooks.Stop.some(
+      h => h.command === 'node' && h.args?.[0] === mcpServerPath
+    );
+
+    if (!sessionEndExists) {
+      config.hooks.Stop.push({
+        type: 'command',
+        command: 'node',
+        args: [mcpServerPath],
+        env: {
+          CLAUDE_HOOK_TYPE: 'SessionEnd',
+          TASKFLOW_SUPABASE_URL: supabaseUrl
+        }
+      });
+    }
+
+    // Write config
+    await fs.writeFile(claudeConfigPath, JSON.stringify(config, null, 2), 'utf-8');
+
+    console.log('✓ TaskFlow MCP server installed successfully!');
+    console.log('\nConfiguration written to:', claudeConfigPath);
+    console.log('\nMCP Server path:', mcpServerPath);
+    console.log('\n📝 Next steps:');
+    console.log('1. Restart Claude Code');
+    console.log('2. Type "@" in chat to see TaskFlow tools');
+    console.log('3. Tools available: create_task, get_tasks, complete_task, etc.');
+    console.log('\n💡 Hooks installed:');
+    console.log('- SessionStart: Loads your tasks automatically');
+    console.log('- SessionEnd: Auto-logs completed work as tasks');
+
+  } catch (error) {
+    console.error('❌ Installation failed:', error.message);
+    process.exit(1);
+  }
+}
+
+install();

package/scripts/install.sh

@@ -0,0 +1,104 @@
+#!/bin/bash
+
+# TaskFlow MCP Server Installation Script
+
+set -e
+
+echo "🚀 Installing TaskFlow MCP Server..."
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+
+# Build the server
+echo "📦 Building MCP server..."
+cd "$PROJECT_ROOT"
+npm run build
+
+# Get the absolute path to dist/index.js
+DIST_PATH="$PROJECT_ROOT/dist/index.js"
+
+# Check if Claude Code config directory exists
+CLAUDE_CONFIG_DIR="$HOME/.config/claude-code"
+
+if [ ! -d "$CLAUDE_CONFIG_DIR" ]; then
+  echo "❌ Claude Code config directory not found at $CLAUDE_CONFIG_DIR"
+  echo "   Make sure Claude Code is installed."
+  exit 1
+fi
+
+# Create or update config.json
+CONFIG_FILE="$CLAUDE_CONFIG_DIR/config.json"
+
+echo "⚙️  Configuring Claude Code..."
+
+# Read existing config or create new
+if [ -f "$CONFIG_FILE" ]; then
+  # Backup existing config
+  cp "$CONFIG_FILE" "$CONFIG_FILE.backup"
+  echo "   Backed up existing config to config.json.backup"
+fi
+
+# Read Supabase key from environment or prompt
+if [ -z "$TASKFLOW_SUPABASE_KEY" ]; then
+  echo ""
+  echo "📝 Please enter your Supabase anon key:"
+  echo "   (Find it at: https://supabase.com/dashboard/project/_/settings/api)"
+  read -r SUPABASE_KEY
+else
+  SUPABASE_KEY="$TASKFLOW_SUPABASE_KEY"
+fi
+
+# Create config with proper paths
+cat > "$CONFIG_FILE" <<EOF
+{
+  "mcpServers": {
+    "taskflow": {
+      "command": "node",
+      "args": [
+        "$DIST_PATH"
+      ],
+      "env": {
+        "TASKFLOW_SUPABASE_URL": "https://cbkkztbcoitrfcleghfd.supabase.co",
+        "TASKFLOW_SUPABASE_KEY": "$SUPABASE_KEY"
+      }
+    }
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "type": "command",
+        "command": "node",
+        "args": ["$DIST_PATH"],
+        "env": {
+          "CLAUDE_HOOK_TYPE": "SessionStart",
+          "TASKFLOW_SUPABASE_URL": "https://cbkkztbcoitrfcleghfd.supabase.co"
+        }
+      }
+    ],
+    "Stop": [
+      {
+        "type": "command",
+        "command": "node",
+        "args": ["$DIST_PATH"],
+        "env": {
+          "CLAUDE_HOOK_TYPE": "SessionEnd",
+          "TASKFLOW_SUPABASE_URL": "https://cbkkztbcoitrfcleghfd.supabase.co"
+        }
+      }
+    ]
+  }
+}
+EOF
+
+echo ""
+echo "✅ TaskFlow MCP Server installed successfully!"
+echo ""
+echo "📍 Configuration written to: $CONFIG_FILE"
+echo "📍 Server location: $DIST_PATH"
+echo ""
+echo "🔄 Next steps:"
+echo "   1. Restart Claude Code"
+echo "   2. Type '@' in a chat to see TaskFlow tools"
+echo "   3. Your tasks will load automatically on session start"
+echo ""

package/scripts/uninstall.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function uninstall() {
+  console.log('🗑️  Uninstalling TaskFlow MCP integration...\n');
+
+  let removedCount = 0;
+
+  try {
+    // 1. Remove from Claude Code config
+    const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    const claudeConfigDir = path.join(configHome, 'claude-code');
+    const claudeConfigPath = path.join(claudeConfigDir, 'config.json');
+
+    try {
+      const configData = await fs.readFile(claudeConfigPath, 'utf-8');
+      const config = JSON.parse(configData);
+
+      // Remove TaskFlow MCP server
+      if (config.mcpServers?.taskflow) {
+        delete config.mcpServers.taskflow;
+        console.log('✓ Removed TaskFlow MCP server from Claude Code config');
+        removedCount++;
+      }
+
+      // Remove SessionStart hook
+      if (config.hooks?.SessionStart) {
+        const mcpServerPath = path.resolve(__dirname, '..', 'dist', 'index.js');
+        config.hooks.SessionStart = config.hooks.SessionStart.filter(
+          h => !(h.command === 'node' && h.args?.[0] === mcpServerPath)
+        );
+        if (config.hooks.SessionStart.length === 0) {
+          delete config.hooks.SessionStart;
+        }
+        console.log('✓ Removed SessionStart hook');
+        removedCount++;
+      }
+
+      // Remove Stop/SessionEnd hook
+      if (config.hooks?.Stop) {
+        const mcpServerPath = path.resolve(__dirname, '..', 'dist', 'index.js');
+        config.hooks.Stop = config.hooks.Stop.filter(
+          h => !(h.command === 'node' && h.args?.[0] === mcpServerPath)
+        );
+        if (config.hooks.Stop.length === 0) {
+          delete config.hooks.Stop;
+        }
+        console.log('✓ Removed SessionEnd hook');
+        removedCount++;
+      }
+
+      // Clean up empty objects
+      if (config.mcpServers && Object.keys(config.mcpServers).length === 0) {
+        delete config.mcpServers;
+      }
+      if (config.hooks && Object.keys(config.hooks).length === 0) {
+        delete config.hooks;
+      }
+
+      await fs.writeFile(claudeConfigPath, JSON.stringify(config, null, 2), 'utf-8');
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.warn('⚠️  Could not update Claude Code config:', error.message);
+      }
+    }
+
+    // 2. Remove CLI config directory
+    const taskflowConfigDir = path.join(configHome, 'taskflow');
+    try {
+      await fs.rm(taskflowConfigDir, { recursive: true, force: true });
+      console.log('✓ Removed CLI config directory');
+      removedCount++;
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.warn('⚠️  Could not remove CLI config:', error.message);
+      }
+    }
+
+    // 3. Note about npm unlink (can't do automatically)
+    console.log('\n📝 Manual steps remaining:');
+    console.log('   1. Unlink CLI globally:');
+    console.log('      cd packages/cli && npm unlink -g');
+    console.log('   2. Remove git hooks (if installed):');
+    console.log('      rm .git/hooks/post-commit');
+    console.log('   3. Clear keychain credentials (macOS/Windows):');
+    console.log('      - macOS: Open Keychain Access → search "taskflow"');
+    console.log('      - Windows: Control Panel → Credential Manager → search "taskflow"');
+
+    console.log(`\n✅ Removed ${removedCount} configuration items`);
+    console.log('\n💡 To complete uninstallation:');
+    console.log('   - Restart Claude Code to apply config changes');
+    console.log('   - Run the manual steps above');
+
+  } catch (error) {
+    console.error('❌ Uninstallation failed:', error.message);
+    process.exit(1);
+  }
+}
+
+uninstall();

package/src/hooks/session-end.ts

@@ -0,0 +1,75 @@
+import { AuthManager, TaskOperations } from '@vibetasks/core';
+
+/**
+ * SessionEnd hook - Auto-log AI session as completed task
+ */
+export async function handleSessionEnd() {
+  try {
+    const authManager = new AuthManager();
+
+    // Check if authenticated
+    const isAuth = await authManager.isAuthenticated();
+    if (!isAuth) {
+      // Silently skip if not authenticated
+      return;
+    }
+
+    // Read session metadata from environment (if provided by Claude Code)
+    const metadataJson = process.env.CLAUDE_SESSION_METADATA || '{}';
+    const metadata = JSON.parse(metadataJson);
+
+    // Check if significant work was done
+    const filesEdited: string[] = metadata.filesEdited || [];
+    const duration: number = metadata.duration || 0;
+    const aiActions: string[] = metadata.aiActions || [];
+
+    // Only create task if significant work happened
+    const shouldLog =
+      filesEdited.length > 0 && duration >= 60000 && aiActions.length > 0;
+
+    if (!shouldLog) {
+      // Session too short or no significant work
+      console.error('TaskFlow: Session too short, not logging');
+      return;
+    }
+
+    const taskOps = await TaskOperations.fromAuthManager(authManager);
+
+    // Create summary
+    const durationMinutes = Math.round(duration / 60000);
+    const primaryAction = aiActions[0] || 'Code changes';
+
+    const summary = `# AI Session Completed
+
+## Summary
+${primaryAction}
+
+## Duration
+${durationMinutes} minutes
+
+## Files Edited (${filesEdited.length})
+${filesEdited.slice(0, 15).map((f) => `- ${f}`).join('\n')}
+${filesEdited.length > 15 ? `\n...and ${filesEdited.length - 15} more files` : ''}
+
+## Actions
+${aiActions.map((a) => `- ${a}`).join('\n')}
+
+---
+*Generated by TaskFlow MCP Server*
+`.trim();
+
+    // Create completed task
+    await taskOps.createTask({
+      title: `AI Session: ${primaryAction}`,
+      notes: summary,
+      notes_format: 'markdown',
+      completed: true,
+      priority: 'none',
+    });
+
+    console.error('TaskFlow: Logged AI session as completed task');
+  } catch (error: any) {
+    // Log error to stderr but don't fail
+    console.error('TaskFlow SessionEnd hook error:', error.message);
+  }
+}

package/src/hooks/session-start.ts

@@ -0,0 +1,74 @@
+import { AuthManager, TaskOperations } from '@vibetasks/core';
+
+/**
+ * SessionStart hook - Load today's tasks as context for AI
+ */
+export async function handleSessionStart() {
+  try {
+    const authManager = new AuthManager();
+
+    // Check if authenticated
+    const isAuth = await authManager.isAuthenticated();
+    if (!isAuth) {
+      // Silently skip if not authenticated
+      console.log(JSON.stringify({ additionalContext: '' }));
+      return;
+    }
+
+    const taskOps = await TaskOperations.fromAuthManager(authManager);
+
+    // Load today's tasks
+    const todayTasks = await taskOps.getTasks('today');
+    const activeTasks = await taskOps.getTasks('all');
+
+    // Format context for AI
+    const context = `# TaskFlow - Your Tasks
+
+## Today's Tasks (${todayTasks.length})
+${
+  todayTasks.length === 0
+    ? 'No tasks due today.'
+    : todayTasks
+        .map((t) => {
+          const priority =
+            t.priority && t.priority !== 'none' ? ` [${t.priority.toUpperCase()}]` : '';
+          const tags = t.tags && t.tags.length > 0 ? ` #${t.tags.map((tag) => tag.name).join(' #')}` : '';
+          return `- [ ] ${t.title}${priority}${tags}`;
+        })
+        .join('\n')
+}
+
+## All Active Tasks (${activeTasks.length})
+${
+  activeTasks.length === 0
+    ? 'No active tasks.'
+    : activeTasks
+        .slice(0, 10)
+        .map((t) => {
+          const priority =
+            t.priority && t.priority !== 'none' ? ` [${t.priority.toUpperCase()}]` : '';
+          const dueDate = t.due_date ? ` (Due: ${t.due_date.split('T')[0]})` : '';
+          return `- [ ] ${t.title}${priority}${dueDate}`;
+        })
+        .join('\n')
+}${activeTasks.length > 10 ? `\n...and ${activeTasks.length - 10} more` : ''}
+
+---
+You can manage tasks using these MCP tools:
+- create_task: Add new tasks
+- get_tasks: View tasks by filter
+- complete_task: Mark tasks done
+- search_tasks: Find tasks
+- update_task: Modify tasks
+- delete_task: Remove tasks
+- log_ai_session: Log what we accomplish together
+`.trim();
+
+    // Return context for Claude Code
+    console.log(JSON.stringify({ additionalContext: context }));
+  } catch (error: any) {
+    // Log error to stderr but don't fail
+    console.error('TaskFlow SessionStart hook error:', error.message);
+    console.log(JSON.stringify({ additionalContext: '' }));
+  }
+}

package/src/index.ts

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+/**
+ * TaskFlow MCP Server
+ * Provides task management integration for Claude Code, Cursor, and other AI coding tools
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { AuthManager, TaskOperations } from '@vibetasks/core';
+import { setupTools } from './tools/index.js';
+import { setupResources } from './resources/index.js';
+
+// Check if running as a hook
+const hookType = process.env.CLAUDE_HOOK_TYPE;
+
+if (hookType === 'SessionStart') {
+  // Handle SessionStart hook
+  const { handleSessionStart } = await import('./hooks/session-start.js');
+  await handleSessionStart();
+  process.exit(0);
+} else if (hookType === 'SessionEnd' || hookType === 'Stop') {
+  // Handle SessionEnd hook
+  const { handleSessionEnd } = await import('./hooks/session-end.js');
+  await handleSessionEnd();
+  process.exit(0);
+}
+
+// Normal MCP server mode
+async function main() {
+  try {
+    // Initialize authentication
+    const authManager = new AuthManager();
+
+    // Supabase configuration with production fallback
+    const supabaseUrl =
+      process.env.TASKFLOW_SUPABASE_URL ||
+      (await authManager.getConfig('supabase_url')) ||
+      'https://cbkkztbcoitrfcleghfd.supabase.co';
+    const supabaseKey =
+      process.env.TASKFLOW_SUPABASE_KEY ||
+      (await authManager.getConfig('supabase_key')) ||
+      'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNia2t6dGJjb2l0cmZjbGVnaGZkIiwicm9sZSI6ImFub24iLCJpYXQiOjE3Njc3NTc0MjgsImV4cCI6MjA4MzMzMzQyOH0.G7ILx-nntP0NbxO1gKt5yASb7nt7OmpJ8qtykeGYbQA';
+    const accessToken = await authManager.getAccessToken();
+
+    if (!accessToken) {
+      console.error('ERROR: Not authenticated.', { severity: 'error' });
+      console.error('Run: taskflow login', { severity: 'error' });
+      process.exit(1);
+    }
+
+    if (!accessToken) {
+      console.error('ERROR: Not authenticated.', { severity: 'error' });
+      console.error('Run: taskflow login', { severity: 'error' });
+      process.exit(1);
+    }
+
+    // Create TaskOperations instance
+    const taskOps = await TaskOperations.fromAuthManager(authManager);
+
+    // Create MCP server
+    const server = new Server(
+      {
+        name: 'taskflow-mcp-server',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+          resources: {},
+        },
+      }
+    );
+
+    // Setup tools and resources
+    const tools = setupTools(taskOps);
+    const resources = setupResources(taskOps);
+
+    // Register tool list handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema,
+        })),
+      };
+    });
+
+    // Register tool call handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const tool = tools.find((t) => t.name === request.params.name);
+
+      if (!tool) {
+        throw new Error(`Unknown tool: ${request.params.name}`);
+      }
+
+      try {
+        return await tool.handler(request.params.arguments || {}, taskOps);
+      } catch (error: any) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(
+                {
+                  success: false,
+                  error: error.message,
+                },
+                null,
+                2
+              ),
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+
+    // Register resource list handler
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return {
+        resources: resources.map((r) => ({
+          uri: r.uri,
+          name: r.name,
+          description: r.description,
+          mimeType: r.mimeType,
+        })),
+      };
+    });
+
+    // Register resource read handler
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const resource = resources.find((r) => r.uri === request.params.uri);
+
+      if (!resource) {
+        throw new Error(`Unknown resource: ${request.params.uri}`);
+      }
+
+      try {
+        return await resource.handler(taskOps);
+      } catch (error: any) {
+        throw new Error(`Failed to read resource: ${error.message}`);
+      }
+    });
+
+    // Connect via STDIO
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+
+    // Log to stderr (STDIO requirement)
+    console.error('TaskFlow MCP server started', { severity: 'info' });
+  } catch (error: any) {
+    console.error('Fatal error:', error, { severity: 'error' });
+    process.exit(1);
+  }
+}
+
+main();