claudehq 1.0.0 → 1.0.2

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
+};