claudehq 1.0.1 → 1.0.3

package/lib/data/plans.js

@@ -0,0 +1,247 @@
+/**
+ * Plans Data Module - Plan loading, updating, and session mapping
+ *
+ * Handles reading and writing plan files from the Claude plans directory.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { PLANS_DIR, PROJECTS_DIR } = require('../core/config');
+const { eventBus, EventTypes } = require('../core/event-bus');
+
+// Cache for plan slug -> sessionId mapping
+const planSessionCache = new Map();
+let planCacheBuilt = false;
+
+/**
+ * Build the plan->session mapping by scanning JSONL files
+ */
+function buildPlanSessionCache() {
+  console.log('  Building plan-session mapping cache...');
+  const startTime = Date.now();
+  planSessionCache.clear();
+
+  if (!fs.existsSync(PLANS_DIR) || !fs.existsSync(PROJECTS_DIR)) {
+    planCacheBuilt = true;
+    return;
+  }
+
+  // Get all plan slugs
+  const planFiles = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'));
+  const slugs = planFiles.map(f => f.replace('.md', ''));
+
+  // Search through project directories for slug references
+  const projectDirs = fs.readdirSync(PROJECTS_DIR);
+
+  for (const projectDir of projectDirs) {
+    const projectPath = path.join(PROJECTS_DIR, projectDir);
+    if (!fs.statSync(projectPath).isDirectory()) continue;
+
+    // Check main jsonl files
+    const jsonlFiles = fs.readdirSync(projectPath).filter(f => f.endsWith('.jsonl'));
+    for (const jsonlFile of jsonlFiles) {
+      try {
+        const content = fs.readFileSync(path.join(projectPath, jsonlFile), 'utf-8');
+        for (const slug of slugs) {
+          if (planSessionCache.has(slug)) continue;
+          if (content.includes(`"slug":"${slug}"`)) {
+            // Find the sessionId in this file
+            const lines = content.split('\n');
+            for (const line of lines) {
+              if (line.includes(`"slug":"${slug}"`)) {
+                try {
+                  const entry = JSON.parse(line);
+                  if (entry.sessionId) {
+                    planSessionCache.set(slug, entry.sessionId);
+                    break;
+                  }
+                } catch (e) {}
+              }
+            }
+          }
+        }
+      } catch (e) {}
+    }
+
+    // Check subagents directory
+    const subagentsPath = path.join(projectPath, 'subagents');
+    if (fs.existsSync(subagentsPath)) {
+      const subagentFiles = fs.readdirSync(subagentsPath).filter(f => f.endsWith('.jsonl'));
+      for (const jsonlFile of subagentFiles) {
+        try {
+          const content = fs.readFileSync(path.join(subagentsPath, jsonlFile), 'utf-8');
+          for (const slug of slugs) {
+            if (planSessionCache.has(slug)) continue;
+            if (content.includes(`"slug":"${slug}"`)) {
+              const lines = content.split('\n');
+              for (const line of lines) {
+                if (line.includes(`"slug":"${slug}"`)) {
+                  try {
+                    const entry = JSON.parse(line);
+                    if (entry.sessionId) {
+                      planSessionCache.set(slug, entry.sessionId);
+                      break;
+                    }
+                  } catch (e) {}
+                }
+              }
+            }
+          }
+        } catch (e) {}
+      }
+    }
+  }
+
+  planCacheBuilt = true;
+  console.log(`  Plan cache built: ${planSessionCache.size} plans mapped in ${Date.now() - startTime}ms`);
+}
+
+/**
+ * Get session ID for a plan slug
+ * @param {string} slug - Plan slug
+ * @returns {string|null} Session ID or null
+ */
+function getSessionForPlan(slug) {
+  if (!planCacheBuilt) buildPlanSessionCache();
+  return planSessionCache.get(slug) || null;
+}
+
+/**
+ * Load all plans with their session mappings
+ * @returns {Array} Array of plan objects
+ */
+function loadAllPlans() {
+  if (!planCacheBuilt) buildPlanSessionCache();
+
+  const plans = [];
+
+  if (!fs.existsSync(PLANS_DIR)) {
+    return plans;
+  }
+
+  const planFiles = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'));
+
+  for (const file of planFiles) {
+    try {
+      const slug = file.replace('.md', '');
+      const filepath = path.join(PLANS_DIR, file);
+      const stats = fs.statSync(filepath);
+      const content = fs.readFileSync(filepath, 'utf-8');
+
+      // Extract title from first heading
+      const titleMatch = content.match(/^#\s+(.+?)(?:\n|$)/m);
+      const title = titleMatch ? titleMatch[1].replace(/^Plan:\s*/i, '') : slug;
+
+      plans.push({
+        slug,
+        title,
+        sessionId: planSessionCache.get(slug) || null,
+        filepath,
+        size: stats.size,
+        modified: stats.mtime.toISOString(),
+        preview: content.substring(0, 200).replace(/\n/g, ' ').trim()
+      });
+    } catch (e) {
+      console.error(`Error loading plan ${file}:`, e.message);
+    }
+  }
+
+  // Sort by modified date, newest first
+  plans.sort((a, b) => new Date(b.modified) - new Date(a.modified));
+
+  return plans;
+}
+
+/**
+ * Get plans for a specific session
+ * @param {string} sessionId - Session ID
+ * @returns {Array} Array of plans for the session
+ */
+function getPlansForSession(sessionId) {
+  const allPlans = loadAllPlans();
+  return allPlans.filter(p => p.sessionId === sessionId);
+}
+
+/**
+ * Get a single plan by slug
+ * @param {string} slug - Plan slug
+ * @returns {Object} Plan object or error
+ */
+function getPlan(slug) {
+  const filepath = path.join(PLANS_DIR, `${slug}.md`);
+
+  if (!fs.existsSync(filepath)) {
+    return { error: 'Plan not found' };
+  }
+
+  try {
+    const content = fs.readFileSync(filepath, 'utf-8');
+    const stats = fs.statSync(filepath);
+    const titleMatch = content.match(/^#\s+(.+?)(?:\n|$)/m);
+    const title = titleMatch ? titleMatch[1].replace(/^Plan:\s*/i, '') : slug;
+
+    return {
+      slug,
+      title,
+      sessionId: getSessionForPlan(slug),
+      content,
+      modified: stats.mtime.toISOString()
+    };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/**
+ * Update a plan's content
+ * @param {string} slug - Plan slug
+ * @param {string} content - New content
+ * @returns {Object} Result with success flag or error
+ */
+function updatePlan(slug, content) {
+  const filepath = path.join(PLANS_DIR, `${slug}.md`);
+
+  if (!fs.existsSync(filepath)) {
+    return { error: 'Plan not found' };
+  }
+
+  try {
+    fs.writeFileSync(filepath, content);
+    const sessionId = getSessionForPlan(slug);
+
+    eventBus.emit(EventTypes.PLAN_UPDATED, { slug, sessionId });
+
+    return { success: true, slug };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/**
+ * Check if plan session cache has been built
+ * @returns {boolean}
+ */
+function isCacheBuilt() {
+  return planCacheBuilt;
+}
+
+/**
+ * Check if a plan slug is in the cache
+ * @param {string} slug - Plan slug
+ * @returns {boolean}
+ */
+function hasPlanInCache(slug) {
+  return planSessionCache.has(slug);
+}
+
+module.exports = {
+  buildPlanSessionCache,
+  getSessionForPlan,
+  loadAllPlans,
+  getPlansForSession,
+  getPlan,
+  updatePlan,
+  isCacheBuilt,
+  hasPlanInCache
+};

package/lib/data/tasks.js

@@ -0,0 +1,263 @@
+/**
+ * Tasks Data Module - Task loading, updating, and creation
+ *
+ * Handles reading and writing task files from the Claude tasks directory.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { TASKS_DIR } = require('../core/config');
+const { eventBus, EventTypes } = require('../core/event-bus');
+
+// Callbacks for enrichment (set by other modules)
+let loadCustomNamesCallback = null;
+let getSessionMetadataCallback = null;
+
+/**
+ * Set callback for loading custom names
+ * @param {Function} callback
+ */
+function setCustomNamesCallback(callback) {
+  loadCustomNamesCallback = callback;
+}
+
+/**
+ * Set callback for getting session metadata
+ * @param {Function} callback
+ */
+function setMetadataCallback(callback) {
+  getSessionMetadataCallback = callback;
+}
+
+/**
+ * Load all tasks from all sessions
+ * @returns {Array} Array of session objects with tasks
+ */
+function loadAllTasks() {
+  const sessions = [];
+
+  if (!fs.existsSync(TASKS_DIR)) {
+    return sessions;
+  }
+
+  const customNames = loadCustomNamesCallback ? loadCustomNamesCallback() : {};
+
+  const sessionDirs = fs.readdirSync(TASKS_DIR).filter(f => {
+    const fullPath = path.join(TASKS_DIR, f);
+    return fs.statSync(fullPath).isDirectory();
+  });
+
+  for (const sessionId of sessionDirs) {
+    const sessionPath = path.join(TASKS_DIR, sessionId);
+    const tasks = [];
+
+    const files = fs.readdirSync(sessionPath).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(sessionPath, file), 'utf-8');
+        const task = JSON.parse(content);
+        task.sessionId = sessionId;
+        tasks.push(task);
+      } catch (e) {
+        console.error(`Error reading ${file}:`, e.message);
+      }
+    }
+
+    tasks.sort((a, b) => parseInt(a.id) - parseInt(b.id));
+
+    const metadata = getSessionMetadataCallback ? getSessionMetadataCallback(sessionId) : { repoName: null, firstPrompt: null };
+    const hasInProgress = tasks.some(t => t.status === 'in_progress');
+    const sessionStatus = hasInProgress ? 'working' : 'idle';
+
+    sessions.push({
+      sessionId,
+      tasks,
+      customName: customNames[sessionId] || null,
+      repoName: metadata.repoName,
+      firstPrompt: metadata.firstPrompt,
+      status: sessionStatus,
+      stats: {
+        total: tasks.length,
+        pending: tasks.filter(t => t.status === 'pending').length,
+        in_progress: tasks.filter(t => t.status === 'in_progress').length,
+        completed: tasks.filter(t => t.status === 'completed').length
+      }
+    });
+  }
+
+  sessions.sort((a, b) => b.tasks.length - a.tasks.length);
+  return sessions;
+}
+
+/**
+ * Get tasks for a specific session
+ * @param {string} sessionId - Session ID
+ * @returns {Object} Session object with tasks
+ */
+function getTasksForSession(sessionId) {
+  const sessionPath = path.join(TASKS_DIR, sessionId);
+
+  if (!fs.existsSync(sessionPath)) {
+    return null;
+  }
+
+  const tasks = [];
+  const files = fs.readdirSync(sessionPath).filter(f => f.endsWith('.json'));
+
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(sessionPath, file), 'utf-8');
+      const task = JSON.parse(content);
+      task.sessionId = sessionId;
+      tasks.push(task);
+    } catch (e) {
+      console.error(`Error reading ${file}:`, e.message);
+    }
+  }
+
+  tasks.sort((a, b) => parseInt(a.id) - parseInt(b.id));
+
+  return {
+    sessionId,
+    tasks,
+    stats: {
+      total: tasks.length,
+      pending: tasks.filter(t => t.status === 'pending').length,
+      in_progress: tasks.filter(t => t.status === 'in_progress').length,
+      completed: tasks.filter(t => t.status === 'completed').length
+    }
+  };
+}
+
+/**
+ * Update a task
+ * @param {string} sessionId - Session ID
+ * @param {string} taskId - Task ID
+ * @param {Object} updates - Updates to apply
+ * @returns {Object} Result with success flag or error
+ */
+function updateTask(sessionId, taskId, updates) {
+  const taskPath = path.join(TASKS_DIR, sessionId, `${taskId}.json`);
+
+  if (!fs.existsSync(taskPath)) {
+    return { error: 'Task not found' };
+  }
+
+  try {
+    const content = fs.readFileSync(taskPath, 'utf-8');
+    const task = JSON.parse(content);
+    const previousStatus = task.status;
+
+    if (updates.status) task.status = updates.status;
+    if (updates.subject !== undefined) task.subject = updates.subject;
+    if (updates.description !== undefined) task.description = updates.description;
+    if (updates.activeForm !== undefined) task.activeForm = updates.activeForm;
+    if (updates.blocks !== undefined) task.blocks = updates.blocks;
+    if (updates.blockedBy !== undefined) task.blockedBy = updates.blockedBy;
+
+    fs.writeFileSync(taskPath, JSON.stringify(task, null, 2));
+
+    eventBus.emit(EventTypes.TASK_UPDATED, { sessionId, taskId, task, updates });
+
+    if (updates.status && updates.status !== previousStatus) {
+      eventBus.emit(EventTypes.TASK_STATUS_CHANGED, {
+        sessionId, taskId, status: updates.status, previousStatus, task
+      });
+    }
+
+    return { success: true, task };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/**
+ * Bulk update multiple tasks
+ * @param {string} sessionId - Session ID
+ * @param {Array} taskIds - Array of task IDs
+ * @param {Object} updates - Updates to apply
+ * @returns {Object} Result with count of updated tasks
+ */
+function bulkUpdateTasks(sessionId, taskIds, updates) {
+  let updated = 0;
+
+  for (const taskId of taskIds) {
+    const result = updateTask(sessionId, taskId, updates);
+    if (result.success) {
+      updated++;
+    }
+  }
+
+  return { ok: true, updated };
+}
+
+/**
+ * Create a new task
+ * @param {string} sessionId - Session ID
+ * @param {Object} taskData - Task data
+ * @returns {Object} Result with success flag and task
+ */
+function createTask(sessionId, taskData) {
+  const sessionPath = path.join(TASKS_DIR, sessionId);
+
+  if (!fs.existsSync(sessionPath)) {
+    return { error: 'Session not found' };
+  }
+
+  try {
+    const files = fs.readdirSync(sessionPath).filter(f => f.endsWith('.json'));
+    const ids = files.map(f => parseInt(f.replace('.json', ''))).filter(n => !isNaN(n));
+    const nextId = ids.length > 0 ? Math.max(...ids) + 1 : 1;
+
+    const task = {
+      id: String(nextId),
+      subject: taskData.subject || 'New Task',
+      description: taskData.description || '',
+      activeForm: taskData.activeForm || '',
+      status: taskData.status || 'pending',
+      blocks: taskData.blocks || [],
+      blockedBy: taskData.blockedBy || []
+    };
+
+    fs.writeFileSync(path.join(sessionPath, `${nextId}.json`), JSON.stringify(task, null, 2));
+
+    eventBus.emit(EventTypes.TASK_CREATED, { sessionId, task });
+
+    return { success: true, task };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/**
+ * Delete a task
+ * @param {string} sessionId - Session ID
+ * @param {string} taskId - Task ID
+ * @returns {Object} Result with success flag
+ */
+function deleteTask(sessionId, taskId) {
+  const taskPath = path.join(TASKS_DIR, sessionId, `${taskId}.json`);
+
+  if (!fs.existsSync(taskPath)) {
+    return { error: 'Task not found' };
+  }
+
+  try {
+    fs.unlinkSync(taskPath);
+    return { success: true };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+module.exports = {
+  loadAllTasks,
+  getTasksForSession,
+  updateTask,
+  bulkUpdateTasks,
+  createTask,
+  deleteTask,
+  setCustomNamesCallback,
+  setMetadataCallback
+};

package/lib/data/todos.js

@@ -0,0 +1,205 @@
+/**
+ * Todos Data Module - Todo loading, updating, and creation
+ *
+ * Handles reading and writing todo files from the Claude todos directory.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { TODOS_DIR } = require('../core/config');
+const { eventBus, EventTypes } = require('../core/event-bus');
+
+/**
+ * Load all todos from all sessions
+ * @returns {Object} Object mapping sessionId to todo data
+ */
+function loadAllTodos() {
+  const todosBySession = {};
+
+  if (!fs.existsSync(TODOS_DIR)) {
+    return todosBySession;
+  }
+
+  try {
+    const files = fs.readdirSync(TODOS_DIR).filter(f => f.endsWith('.json'));
+
+    for (const file of files) {
+      try {
+        // Extract session ID from filename (format: {sessionId}-agent-{sessionId}.json)
+        const match = file.match(/^([a-f0-9-]+)-agent-/);
+        if (!match) continue;
+
+        const sessionId = match[1];
+        const content = fs.readFileSync(path.join(TODOS_DIR, file), 'utf-8');
+        const todos = JSON.parse(content);
+
+        // Skip empty arrays
+        if (!Array.isArray(todos) || todos.length === 0) continue;
+
+        // Add index-based IDs if not present
+        const todosWithIds = todos.map((todo, idx) => ({
+          ...todo,
+          id: todo.id || String(idx + 1)
+        }));
+
+        todosBySession[sessionId] = {
+          sessionId,
+          todos: todosWithIds,
+          stats: {
+            total: todosWithIds.length,
+            pending: todosWithIds.filter(t => t.status === 'pending').length,
+            in_progress: todosWithIds.filter(t => t.status === 'in_progress').length,
+            completed: todosWithIds.filter(t => t.status === 'completed').length
+          }
+        };
+      } catch (e) {
+        // Skip invalid files
+      }
+    }
+  } catch (e) {
+    console.error('Error loading todos:', e.message);
+  }
+
+  return todosBySession;
+}
+
+/**
+ * Get todos for a specific session
+ * @param {string} sessionId - Session ID
+ * @returns {Object} Session object with todos
+ */
+function getTodosForSession(sessionId) {
+  const emptyResult = { sessionId, todos: [], stats: { total: 0, pending: 0, in_progress: 0, completed: 0 } };
+
+  if (!fs.existsSync(TODOS_DIR)) {
+    return emptyResult;
+  }
+
+  // Look for file matching the session ID pattern
+  const filename = `${sessionId}-agent-${sessionId}.json`;
+  const filepath = path.join(TODOS_DIR, filename);
+
+  if (!fs.existsSync(filepath)) {
+    return emptyResult;
+  }
+
+  try {
+    const content = fs.readFileSync(filepath, 'utf-8');
+    const todos = JSON.parse(content);
+
+    if (!Array.isArray(todos)) {
+      return emptyResult;
+    }
+
+    const todosWithIds = todos.map((todo, idx) => ({
+      ...todo,
+      id: todo.id || String(idx + 1)
+    }));
+
+    return {
+      sessionId,
+      todos: todosWithIds,
+      stats: {
+        total: todosWithIds.length,
+        pending: todosWithIds.filter(t => t.status === 'pending').length,
+        in_progress: todosWithIds.filter(t => t.status === 'in_progress').length,
+        completed: todosWithIds.filter(t => t.status === 'completed').length
+      }
+    };
+  } catch (e) {
+    return emptyResult;
+  }
+}
+
+/**
+ * Update a todo
+ * @param {string} sessionId - Session ID
+ * @param {number} todoIndex - Index of the todo
+ * @param {Object} updates - Updates to apply
+ * @returns {Object} Result with success flag or error
+ */
+function updateTodo(sessionId, todoIndex, updates) {
+  const filename = `${sessionId}-agent-${sessionId}.json`;
+  const filepath = path.join(TODOS_DIR, filename);
+
+  if (!fs.existsSync(filepath)) {
+    return { error: 'Todo file not found' };
+  }
+
+  try {
+    const content = fs.readFileSync(filepath, 'utf-8');
+    const todos = JSON.parse(content);
+
+    if (!Array.isArray(todos) || todoIndex >= todos.length) {
+      return { error: 'Todo not found' };
+    }
+
+    const previousStatus = todos[todoIndex].status;
+
+    if (updates.status) todos[todoIndex].status = updates.status;
+    if (updates.content !== undefined) todos[todoIndex].content = updates.content;
+    if (updates.activeForm !== undefined) todos[todoIndex].activeForm = updates.activeForm;
+
+    fs.writeFileSync(filepath, JSON.stringify(todos, null, 2));
+
+    const todo = { ...todos[todoIndex], id: todos[todoIndex].id || String(todoIndex + 1) };
+
+    // Emit events
+    eventBus.emit(EventTypes.TODO_UPDATED, { sessionId, todoIndex, todo, updates });
+
+    if (updates.status && updates.status !== previousStatus) {
+      eventBus.emit(EventTypes.TODO_STATUS_CHANGED, {
+        sessionId, todoIndex, status: updates.status, previousStatus, todo
+      });
+    }
+
+    return { success: true, todo };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+/**
+ * Create a new todo
+ * @param {string} sessionId - Session ID
+ * @param {Object} todoData - Todo data
+ * @returns {Object} Result with success flag and todo
+ */
+function createTodo(sessionId, todoData) {
+  const filename = `${sessionId}-agent-${sessionId}.json`;
+  const filepath = path.join(TODOS_DIR, filename);
+
+  try {
+    let todos = [];
+    if (fs.existsSync(filepath)) {
+      const content = fs.readFileSync(filepath, 'utf-8');
+      todos = JSON.parse(content);
+      if (!Array.isArray(todos)) todos = [];
+    }
+
+    const todo = {
+      content: todoData.content || 'New todo',
+      status: todoData.status || 'pending',
+      activeForm: todoData.activeForm || ''
+    };
+
+    todos.push(todo);
+    fs.writeFileSync(filepath, JSON.stringify(todos, null, 2));
+
+    const todoWithId = { ...todo, id: String(todos.length) };
+
+    eventBus.emit(EventTypes.TODO_CREATED, { sessionId, todo: todoWithId });
+
+    return { success: true, todo: todoWithId };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+module.exports = {
+  loadAllTodos,
+  getTodosForSession,
+  updateTodo,
+  createTodo
+};