@mod-computer/cli 0.2.4 → 0.2.5

package/dist/commands/claude-sync.js

@@ -1,772 +0,0 @@
-#!/usr/bin/env node
-/**
- * Claude Code Event Sync Tool
- * Syncs Claude Code events with Mod system (branches, threads, tasks, history)
- */
-import { readModConfig } from '../services/mod-config.js';
-import path from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-function isWorkspaceHistoryFile(filePath) {
-    if (!filePath)
-        return false;
-    const normalized = filePath.replace(/\\/g, '/');
-    if (!normalized)
-        return false;
-    if (normalized === '.claude' || normalized === '/.claude')
-        return false;
-    if (normalized.startsWith('.claude/'))
-        return false;
-    if (normalized.includes('/.claude/'))
-        return false;
-    if (normalized.endsWith('/.claude'))
-        return false;
-    return true;
-}
-export async function claudeSyncCommand(args, repo) {
-    // Check for --payload-stdin flag
-    if (args.includes('--payload-stdin')) {
-        // await processPayloadFromStdin(repo); // Commented out - needs refactoring
-        return;
-    }
-    const subcommand = args[0];
-    if (!subcommand) {
-        console.log(`
-Claude Code Event Sync Tool
-
-Usage:
-  mod claude-sync <command> [options]
-
-Commands:
-  sync-events              # Sync all tracked events to Mod system
-  create-session <id>      # Create branch/thread for specific session
-  sync-file-updates        # Sync file updates to history
-  sync-todos               # Sync todo tracking to tasks
-  sync-conversations       # Sync conversation content to threads
-  status                   # Show sync status
-  help                     # Show this help
-
-Examples:
-  mod claude-sync sync-events
-  mod claude-sync create-session 1faa82b3-6d63-4e39-8784-207d7fbf83c0
-  mod claude-sync status
-`);
-        return;
-    }
-    const cfg = readModConfig();
-    if (!cfg?.workspaceId) {
-        console.error('❌ No active workspace configured in .mod/config.json');
-        process.exit(1);
-    }
-    // TODO: Replace with ModWorkspace/WorkspaceHandle approach
-    console.error('❌ claude-sync needs refactoring to work with new ModWorkspace approach');
-    process.exit(1);
-}
-/* COMMENTED OUT - Needs refactoring for new ModWorkspace approach
-  const cache = getCliRepoCache(repo as any);
-  const workspaceContext = await cache.ensureBranchContext({
-    workspaceId: cfg.workspaceId,
-    branchId: '', // Will be resolved by the cache
-    waitForHydration: true
-  });
-  const { workspace, branchesDocId, branch } = workspaceContext;
-  
-  if (!workspace || !branch) {
-    console.error('❌ Failed to resolve workspace context');
-    process.exit(1);
-  }
-  
-  const workspaceId = workspace.id;
-  const branchId = branch.id;
-
-  const workspaceService = new WorkspaceService(repo);
-  const branchService = new BranchService(repo);
-  const threadService = new ThreadService(repo);
-  const taskService = new TaskService(repo);
-  const changeLogService = new ChangeLogService(repo);
-
-  const projectDir = process.cwd();
-  const stateDir = path.join(projectDir, '.claude', 'state');
-  const logDir = path.join(projectDir, '.claude', 'logs');
-  const conversationsDir = path.join(projectDir, '.claude', 'conversations');
-
-  switch (subcommand) {
-    case 'sync-events':
-      await syncAllEvents(workspaceService, branchService, threadService, taskService, changeLogService, {
-        workspaceId, branchId, branchesDocId, projectDir, stateDir, logDir, conversationsDir
-      });
-      break;
-    
-    case 'create-session':
-      const sessionId = args[1];
-      if (!sessionId) {
-        console.error('❌ Session ID required: mod claude-sync create-session <session-id>');
-        process.exit(1);
-      }
-      await createSessionBranchThread(workspaceService, branchService, threadService, {
-        workspaceId, branchId, branchesDocId, sessionId, projectDir, stateDir
-      });
-      break;
-    
-    case 'sync-file-updates':
-      await syncFileUpdates(taskService, changeLogService, { branchId, branchesDocId, projectDir, logDir });
-      break;
-    
-    case 'sync-todos':
-      await syncTodos(taskService, { branchId, branchesDocId, projectDir, logDir });
-      break;
-    
-    case 'sync-conversations':
-      await syncConversations(threadService, { branchId, branchesDocId, projectDir, conversationsDir });
-      break;
-    
-    case 'status':
-      await showSyncStatus({ projectDir, stateDir, logDir, conversationsDir });
-      break;
-    
-    case 'help':
-      console.log(`
-Claude Code Event Sync Tool
-
-This tool integrates Claude Code activity with your Mod workspace by:
-
-1. Creating new branches/threads for each Claude Code session
-2. Tracking file updates in task history
-3. Syncing todo tracking to Mod tasks
-4. Adding conversation content to threads
-
-Commands:
-  sync-events              # Full sync of all tracked data
-  create-session <id>      # Create branch/thread for specific session
-  sync-file-updates        # Sync file updates to history
-  sync-todos               # Sync todo tracking to tasks
-  sync-conversations       # Sync conversation content to threads
-  status                   # Show sync status
-
-The tool reads from:
-  .claude/logs/events-*.jsonl     # Event logs
-  .claude/conversations/*.json    # Conversation data
-  .claude/state/sessions.json     # Session mappings
-`);
-      break;
-    
-    default:
-      console.error(`❌ Unknown command: ${subcommand}`);
-      console.log('Run "mod claude-sync help" for usage information');
-      process.exit(1);
-  }
-}
-
-async function syncAllEvents(
-  workspaceService: WorkspaceService,
-  branchService: BranchService,
-  threadService: ThreadService,
-  taskService: TaskService,
-  changeLogService: ChangeLogService,
-  context: any
-) {
-  console.log('🔄 Starting full Claude Code event sync...');
-  
-  // Load session mappings
-  const sessionMapping = loadSessionMapping(context.stateDir);
-  
-  // Process all events
-  const events = loadAllEvents(context.logDir);
-  console.log(`📊 Found ${events.length} events across ${new Set(events.map(e => e.session_id)).size} sessions`);
-  
-  // Group events by session
-  const eventsBySession = groupEventsBySession(events);
-  
-  for (const [sessionId, sessionEvents] of eventsBySession) {
-    console.log(`\n📝 Processing session: ${sessionId}`);
-    
-    // Create branch/thread if not exists
-    if (!sessionMapping[sessionId]?.threadId) {
-      await createSessionBranchThread(workspaceService, branchService, threadService, {
-        ...context, sessionId
-      });
-    }
-    
-    // Sync file updates
-    await syncFileUpdatesForSession(taskService, changeLogService, {
-      ...context, sessionId, events: sessionEvents
-    });
-    
-    // Sync todos
-    await syncTodosForSession(taskService, {
-      ...context, sessionId, events: sessionEvents
-    });
-    
-    // Sync conversation
-    await syncConversationForSession(threadService, {
-      ...context, sessionId
-    });
-  }
-  
-  console.log('\n✅ Full sync complete!');
-}
-
-async function createSessionBranchThread(
-  workspaceService: WorkspaceService,
-  branchService: BranchService,
-  threadService: ThreadService,
-  context: any
-) {
-  const { workspaceId, branchId, branchesDocId, sessionId, projectDir, stateDir } = context;
-  
-  console.log(`🏗️  Creating branch/thread for session: ${sessionId}`);
-  
-  try {
-    // Create new branch for this session
-    const branchName = `claude-session-${sessionId.substring(0, 8)}`;
-    const newBranch = await branchService.createBranch(
-      branchId, // parent branch
-      branchName,
-      workspaceId,
-      'thread',
-      'claude-code',
-      branchesDocId
-    );
-    
-    // Create thread for the branch
-    const threadName = `Claude Session ${sessionId.substring(0, 8)}`;
-    const newThread = await threadService.createThreadWithBranch(
-      workspaceId,
-      branchesDocId,
-      newBranch.id,
-      threadName
-    );
-    
-    // Update session mapping
-    updateSessionMapping(stateDir, sessionId, {
-      threadId: newThread.id,
-      branchId: newBranch.id,
-      firstSeen: new Date().toISOString(),
-      lastActivity: new Date().toISOString()
-    });
-    
-    console.log(`✅ Created branch: ${branchName} (${newBranch.id})`);
-    console.log(`✅ Created thread: ${threadName} (${newThread.id})`);
-    
-  } catch (error) {
-    console.error(`❌ Failed to create branch/thread for session ${sessionId}:`, error);
-  }
-}
-
-async function syncFileUpdates(
-  taskService: TaskService,
-  changeLogService: ChangeLogService,
-  context: any
-) {
-  console.log('📁 Syncing file updates to history...');
-  
-  const events = loadAllEvents(context.logDir);
-  const fileEvents = events.filter(e => e.tool_name === 'Write' || e.tool_name === 'Edit');
-  
-  console.log(`📊 Found ${fileEvents.length} file update events`);
-  
-  for (const event of fileEvents) {
-    if (event.file_path) {
-      if (!isWorkspaceHistoryFile(event.file_path)) {
-        console.log(`⏭️  Skipping Claude internal file: ${event.file_path}`);
-        continue;
-      }
-      try {
-        // Create or get task for this session
-        const taskId = await getOrCreateTaskForSession(taskService, context, event.session_id, {
-          description: `File update: ${path.basename(event.file_path)}`,
-          source: 'claude-code',
-          sessionId: event.session_id
-        });
-        
-        // Add file update to task
-        const fileId = path.basename(event.file_path); // Simplified file ID
-        await taskService.addFileUpdateToTask(
-          taskId,
-          fileId,
-          'unknown', // before head
-          'current'  // after head
-        );
-        
-        console.log(`✅ Tracked file update: ${event.file_path}`);
-        
-      } catch (error) {
-        console.error(`❌ Failed to track file update for ${event.file_path}:`, error);
-      }
-    }
-  }
-}
-
-async function syncTodos(
-  taskService: TaskService,
-  context: any
-) {
-  console.log('📋 Syncing todos to tasks...');
-  
-  const events = loadAllEvents(context.logDir);
-  const todoEvents = events.filter(e => e.tool_name === 'TodoWrite');
-  
-  console.log(`📊 Found ${todoEvents.length} todo events`);
-  
-  for (const event of todoEvents) {
-    try {
-      const todos = event.tool_input?.todos || [];
-      
-      for (const todo of todos) {
-        const taskId = await getOrCreateTaskForSession(taskService, context, event.session_id, {
-          description: todo.content,
-          status: todo.status === 'in_progress' ? 'in-progress' :
-                  todo.status === 'completed' ? 'complete' : 'pending',
-          source: 'claude-code',
-          sessionId: event.session_id,
-          todoId: todo.id
-        });
-        
-        console.log(`✅ Synced todo: ${todo.content} (${todo.status})`);
-      }
-      
-    } catch (error) {
-      console.error(`❌ Failed to sync todos for session ${event.session_id}:`, error);
-    }
-  }
-}
-
-async function syncConversations(
-  threadService: ThreadService,
-  context: any
-) {
-  console.log('💬 Syncing conversations to threads...');
-  
-  if (!fs.existsSync(context.conversationsDir)) {
-    console.log('📁 No conversations directory found');
-    return;
-  }
-  
-  const conversationFiles = fs.readdirSync(context.conversationsDir)
-    .filter(f => f.endsWith('.json') && !f.endsWith('-summary.json'));
-  
-  console.log(`📊 Found ${conversationFiles.length} conversations`);
-  
-  for (const file of conversationFiles) {
-    const sessionId = file.replace('.json', '');
-    const conversationPath = path.join(context.conversationsDir, file);
-    
-    try {
-      const conversation = JSON.parse(fs.readFileSync(conversationPath, 'utf8'));
-      
-      // Add conversation as thread items
-      for (const message of conversation) {
-        if (message.role && message.content) {
-          // This would need to be implemented based on your thread item structure
-          console.log(`📝 Would add message: ${message.role} - ${JSON.stringify(message.content).substring(0, 100)}...`);
-        }
-      }
-      
-      console.log(`✅ Synced conversation: ${sessionId}`);
-      
-    } catch (error) {
-      console.error(`❌ Failed to sync conversation ${sessionId}:`, error);
-    }
-  }
-}
-
-async function syncFileUpdatesForSession(
-  taskService: TaskService,
-  changeLogService: ChangeLogService,
-  context: any
-) {
-  const { sessionId, events } = context;
-  const fileEvents = events.filter(e => e.tool_name === 'Write' || e.tool_name === 'Edit');
-  
-  for (const event of fileEvents) {
-    if (event.file_path) {
-      if (!isWorkspaceHistoryFile(event.file_path)) {
-        console.log(`⏭️  Skipping Claude internal file: ${event.file_path}`);
-        continue;
-      }
-      try {
-        const taskId = await getOrCreateTaskForSession(taskService, context, sessionId, {
-          description: `File update: ${path.basename(event.file_path)}`,
-          source: 'claude-code',
-          sessionId: sessionId
-        });
-        
-        const fileId = path.basename(event.file_path);
-        await taskService.addFileUpdateToTask(taskId, fileId, 'unknown', 'current');
-        
-      } catch (error) {
-        console.error(`❌ Failed to track file update:`, error);
-      }
-    }
-  }
-}
-
-async function syncTodosForSession(
-  taskService: TaskService,
-  context: any
-) {
-  const { sessionId, events } = context;
-  const todoEvents = events.filter(e => e.tool_name === 'TodoWrite');
-  
-  for (const event of todoEvents) {
-    const todos = event.tool_input?.todos || [];
-    
-    for (const todo of todos) {
-      try {
-        await getOrCreateTaskForSession(taskService, context, sessionId, {
-          description: todo.content,
-          status: todo.status === 'in_progress' ? 'in-progress' :
-                  todo.status === 'completed' ? 'complete' : 'pending',
-          source: 'claude-code',
-          sessionId: sessionId,
-          todoId: todo.id
-        });
-        
-      } catch (error) {
-        console.error(`❌ Failed to sync todo:`, error);
-      }
-    }
-  }
-}
-
-async function syncConversationForSession(
-  threadService: ThreadService,
-  context: any
-) {
-  const { sessionId, conversationsDir } = context;
-  const conversationPath = path.join(conversationsDir, `${sessionId}.json`);
-  
-  if (fs.existsSync(conversationPath)) {
-    try {
-      const conversation = JSON.parse(fs.readFileSync(conversationPath, 'utf8'));
-      console.log(`📝 Synced ${conversation.length} messages for session ${sessionId}`);
-      
-      // TODO: Add conversation messages to thread
-      // This would require implementing thread item creation
-      
-    } catch (error) {
-      console.error(`❌ Failed to sync conversation:`, error);
-    }
-  }
-}
-
-async function getOrCreateTaskForSession(
-  taskService: TaskService,
-  context: any,
-  sessionId: string,
-  taskData: any
-): Promise<string> {
-  // This is a simplified implementation
-  // In practice, you'd need to:
-  // 1. Get the tasksDocId for the session's branch
-  // 2. Check if a task already exists for this session/todo
-  // 3. Create or update the task accordingly
-  
-  const task = {
-    branchId: context.branchId, // This should be the session's branch ID
-    description: taskData.description,
-    metadata: {
-      createdBy: 'claude-sync',
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      status: taskData.status || 'pending',
-      source: taskData.source,
-      claude: {
-        sessionId: taskData.sessionId,
-        todoId: taskData.todoId
-      }
-    }
-  };
-  
-  // This would need to be implemented with proper task creation
-  return `task-${sessionId}-${Date.now()}`;
-}
-
-async function showSyncStatus(context: any) {
-  console.log('📊 Claude Code Sync Status');
-  console.log('==========================');
-  
-  const { projectDir, stateDir, logDir, conversationsDir } = context;
-  
-  // Check event logs
-  if (fs.existsSync(logDir)) {
-    const logFiles = fs.readdirSync(logDir).filter(f => f.startsWith('events-'));
-    const totalEvents = logFiles.reduce((sum, file) => {
-      const content = fs.readFileSync(path.join(logDir, file), 'utf8');
-      return sum + content.split('\n').filter(line => line.trim()).length;
-    }, 0);
-    
-    console.log(`📝 Event Logs: ${logFiles.length} files, ${totalEvents} events`);
-  } else {
-    console.log('📝 Event Logs: No logs found');
-  }
-  
-  // Check conversations
-  if (fs.existsSync(conversationsDir)) {
-    const convFiles = fs.readdirSync(conversationsDir).filter(f => f.endsWith('.json') && !f.endsWith('-summary.json'));
-    console.log(`💬 Conversations: ${convFiles.length} tracked`);
-  } else {
-    console.log('💬 Conversations: None tracked');
-  }
-  
-  // Check session mappings
-  if (fs.existsSync(path.join(stateDir, 'sessions.json'))) {
-    const sessions = JSON.parse(fs.readFileSync(path.join(stateDir, 'sessions.json'), 'utf8'));
-    console.log(`👥 Sessions: ${Object.keys(sessions).length} tracked`);
-  } else {
-    console.log('👥 Sessions: None tracked');
-  }
-}
-
-function loadSessionMapping(stateDir: string): SessionMapping {
-  const mappingPath = path.join(stateDir, 'session-mapping.json');
-  if (fs.existsSync(mappingPath)) {
-    return JSON.parse(fs.readFileSync(mappingPath, 'utf8'));
-  }
-  return {};
-}
-
-function updateSessionMapping(stateDir: string, sessionId: string, data: any) {
-  const mappingPath = path.join(stateDir, 'session-mapping.json');
-  const mapping = loadSessionMapping(stateDir);
-  
-  mapping[sessionId] = {
-    ...mapping[sessionId],
-    ...data,
-    lastActivity: new Date().toISOString()
-  };
-  
-  fs.writeFileSync(mappingPath, JSON.stringify(mapping, null, 2));
-}
-
-function loadAllEvents(logDir: string): ClaudeEvent[] {
-  if (!fs.existsSync(logDir)) return [];
-  
-  const events: ClaudeEvent[] = [];
-  const logFiles = fs.readdirSync(logDir).filter(f => f.startsWith('events-'));
-  
-  for (const file of logFiles) {
-    const content = fs.readFileSync(path.join(logDir, file), 'utf8');
-    const lines = content.split('\n').filter(line => line.trim());
-    
-    for (const line of lines) {
-      try {
-        events.push(JSON.parse(line));
-      } catch (error) {
-        console.warn(`⚠️  Failed to parse event: ${line.substring(0, 100)}...`);
-      }
-    }
-  }
-  
-  return events;
-}
-
-function groupEventsBySession(events: ClaudeEvent[]): Map<string, ClaudeEvent[]> {
-  const grouped = new Map<string, ClaudeEvent[]>();
-  
-  for (const event of events) {
-    if (!grouped.has(event.session_id)) {
-      grouped.set(event.session_id, []);
-    }
-    grouped.get(event.session_id)!.push(event);
-  }
-  
-  return grouped;
-}
-
-async function processPayloadFromStdin(repo: Repo): Promise<void> {
-  try {
-    // Read payload from stdin
-    let payload = '';
-    process.stdin.setEncoding('utf8');
-    
-    for await (const chunk of process.stdin) {
-      payload += chunk;
-    }
-    
-    if (!payload.trim()) {
-      console.error('❌ No payload received from stdin');
-      process.exit(1);
-    }
-    
-    const eventData = JSON.parse(payload);
-    console.log(`🔄 Processing Claude Code event: ${eventData.tool_name} (session: ${eventData.session_id?.substring(0, 8) || 'unknown'})`);
-    
-    // Get workspace context
-    const cfg = readModConfig();
-    if (!cfg?.workspaceId) {
-      console.error('❌ No active workspace configured in .mod/config.json');
-      process.exit(1);
-    }
-    
-    // TODO: Replace with ModWorkspace/WorkspaceHandle approach
-    console.error('❌ claude-sync needs refactoring to work with new ModWorkspace approach');
-    process.exit(1);
-    
-    /*
-    const cache = getCliRepoCache(repo as any);
-    const workspaceContext = await cache.ensureBranchContext({
-      workspaceId: cfg.workspaceId,
-      branchId: '', // Will be resolved by the cache
-      waitForHydration: true
-    });
-    const { workspace, branchesDocId, branch } = workspaceContext;
-    
-    if (!workspace || !branch) {
-      console.error('❌ Failed to resolve workspace context');
-      process.exit(1);
-    }
-    
-    const workspaceId = workspace.id;
-    const branchId = branch.id;
-    
-    // Initialize services
-    const workspaceService = new WorkspaceService(repo);
-    const branchService = new BranchService(repo);
-    const threadService = new ThreadService(repo);
-    const taskService = new TaskService(repo);
-    const changeLogService = new ChangeLogService(repo);
-    
-    const projectDir = process.cwd();
-    const stateDir = path.join(projectDir, '.claude', 'state');
-    
-    // Process the event based on tool type
-    const sessionId = eventData.session_id;
-    const toolName = eventData.tool_name;
-    const filePath = eventData.tool_input?.file_path;
-    
-    if (!sessionId) {
-      console.error('❌ No session_id in payload');
-      process.exit(1);
-    }
-    
-    // Check if this is a new session and create branch/thread if needed
-    const sessionMappingFile = path.join(stateDir, 'session-mapping.json');
-    let sessionMapping: SessionMapping = {};
-    
-    if (fs.existsSync(sessionMappingFile)) {
-      try {
-        sessionMapping = JSON.parse(fs.readFileSync(sessionMappingFile, 'utf8'));
-      } catch (e) {
-        console.warn('⚠️  Could not read session mapping file');
-      }
-    }
-    
-    const isNewSession = !sessionMapping[sessionId];
-    
-    if (isNewSession) {
-      console.log(`🆕 New Claude Code session detected: ${sessionId.substring(0, 8)}`);
-      
-      // Create branch/thread for this session
-      await createSessionBranchThread(workspaceService, branchService, threadService, {
-        workspaceId, branchId, branchesDocId, sessionId, projectDir, stateDir
-      });
-      
-      // Update session mapping
-      sessionMapping[sessionId] = {
-        firstSeen: new Date().toISOString(),
-        lastActivity: new Date().toISOString()
-      };
-    } else {
-      // Update last activity
-      sessionMapping[sessionId].lastActivity = new Date().toISOString();
-    }
-    
-    // Process specific tool events
-    switch (toolName) {
-      case 'Write':
-      case 'Edit':
-        if (filePath) {
-          if (!isWorkspaceHistoryFile(filePath)) {
-            console.log(`⏭️  Skipping Claude internal file: ${filePath}`);
-            break;
-          }
-          console.log(`📁 File update detected: ${path.basename(filePath)}`);
-          // Create a task for this file update
-          const taskDescription = `File update: ${path.basename(filePath)}`;
-          const taskId = await createTaskForSession(taskService, branchId, branchesDocId, taskDescription, sessionId);
-          if (taskId) {
-            console.log(`✅ Created task for file update: ${taskId}`);
-          }
-        }
-        break;
-        
-      case 'TodoWrite':
-        console.log(`📋 Todo update detected`);
-        const todos = eventData.tool_input?.todos || [];
-        for (const todo of todos) {
-          if (todo.content) {
-            // Map todo status to valid task status
-            let taskStatus: 'pending' | 'in-progress' | 'complete' | 'rejected' = 'pending';
-            if (todo.status === 'completed') taskStatus = 'complete';
-            else if (todo.status === 'in_progress') taskStatus = 'in-progress';
-            
-            const taskId = await createTaskForSession(taskService, branchId, branchesDocId, todo.content, sessionId, taskStatus);
-            if (taskId) {
-              console.log(`✅ Created task for todo: ${todo.content} (${taskStatus})`);
-            }
-          }
-        }
-        break;
-        
-      default:
-        console.log(`🔧 Tool usage: ${toolName}`);
-    }
-    
-    // Save updated session mapping
-    fs.mkdirSync(stateDir, { recursive: true });
-    fs.writeFileSync(sessionMappingFile, JSON.stringify(sessionMapping, null, 2));
-    
-    console.log(`✅ Event processed successfully for session: ${sessionId.substring(0, 8)}`);
-    
-  } catch (error) {
-    console.error('❌ Error processing payload:', error);
-    process.exit(1);
-  }
-}
-
-async function createTaskForSession(
-  taskService: TaskService,
-  branchId: string,
-  branchesDocId: string,
-  description: string,
-  sessionId: string,
-  status: 'pending' | 'in-progress' | 'complete' | 'rejected' = 'pending'
-): Promise<string | null> {
-  try {
-    // Ensure tasks doc exists for the branch
-    const tasksDocId = await taskService.getOrCreateTasksDocForBranch(branchId, branchesDocId);
-    
-    // Create task
-    const taskDoc = await taskService.createTask(tasksDocId, {
-      description,
-      branchId,
-      context: {
-        files: [],
-        links: []
-      },
-      subtasks: [],
-      filesUpdated: [],
-      threadItemIds: [],
-      metadata: {
-        createdBy: 'claude-sync',
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        status,
-        source: 'claude-code',
-        claude: {
-          sessionId
-        }
-      }
-    });
-    
-    return taskDoc.id;
-  } catch (error) {
-    console.error('❌ Failed to create task:', error);
-    return null;
-  }
-}
-
-// Close comment blocks
-*/