claudehq 1.0.1 → 1.0.2

package/lib/core/watchers.js

@@ -0,0 +1,127 @@
+/**
+ * File Watchers Module - Watch for file system changes
+ *
+ * Watches task, todo, plan, and conversation directories for changes
+ * and emits events through the EventBus.
+ */
+
+const fs = require('fs');
+const {
+  TASKS_DIR,
+  TODOS_DIR,
+  PLANS_DIR,
+  PROJECTS_DIR,
+  EVENT_DEBOUNCE_DELAY
+} = require('./config');
+const { eventBus, EventTypes } = require('./event-bus');
+
+let watchDebounce = null;
+
+// Callback for rebuilding plan cache (set by plans module)
+let rebuildPlanCacheCallback = null;
+let getSessionForPlanCallback = null;
+
+/**
+ * Set callback for rebuilding plan cache
+ * @param {Function} callback
+ */
+function setPlanCacheCallbacks(rebuildCallback, getSessionCallback) {
+  rebuildPlanCacheCallback = rebuildCallback;
+  getSessionForPlanCallback = getSessionCallback;
+}
+
+/**
+ * Setup all file watchers
+ */
+function setupWatchers() {
+  // Watch tasks directory
+  if (fs.existsSync(TASKS_DIR)) {
+    fs.watch(TASKS_DIR, { recursive: true }, (eventType, filename) => {
+      if (filename && filename.endsWith('.json')) {
+        clearTimeout(watchDebounce);
+        watchDebounce = setTimeout(() => {
+          eventBus.emit(EventTypes.FILE_CHANGED, {
+            type: 'task',
+            filename,
+            directory: TASKS_DIR
+          });
+        }, EVENT_DEBOUNCE_DELAY);
+      }
+    });
+    console.log(`  Watching for changes in: ${TASKS_DIR}`);
+  }
+
+  // Watch projects directory for conversation updates
+  if (fs.existsSync(PROJECTS_DIR)) {
+    fs.watch(PROJECTS_DIR, { recursive: true }, (eventType, filename) => {
+      if (filename && filename.endsWith('.jsonl')) {
+        clearTimeout(watchDebounce);
+        watchDebounce = setTimeout(() => {
+          eventBus.emit(EventTypes.FILE_CHANGED, {
+            type: 'conversation',
+            filename,
+            directory: PROJECTS_DIR
+          });
+        }, 200);
+      }
+    });
+    console.log(`  Watching for conversation updates in: ${PROJECTS_DIR}`);
+  }
+
+  // Watch todos directory for changes
+  if (fs.existsSync(TODOS_DIR)) {
+    fs.watch(TODOS_DIR, (eventType, filename) => {
+      if (filename && filename.endsWith('.json')) {
+        clearTimeout(watchDebounce);
+        watchDebounce = setTimeout(() => {
+          // Extract session ID from filename
+          const match = filename.match(/^([a-f0-9-]+)-agent-/);
+          const sessionId = match ? match[1] : null;
+
+          eventBus.emit(EventTypes.TODOS_CHANGED, {
+            type: 'todo',
+            filename,
+            sessionId,
+            directory: TODOS_DIR
+          });
+        }, EVENT_DEBOUNCE_DELAY);
+      }
+    });
+    console.log(`  Watching for todo changes in: ${TODOS_DIR}`);
+  }
+
+  // Watch plans directory for changes
+  if (fs.existsSync(PLANS_DIR)) {
+    fs.watch(PLANS_DIR, (eventType, filename) => {
+      if (filename && filename.endsWith('.md')) {
+        clearTimeout(watchDebounce);
+        watchDebounce = setTimeout(() => {
+          const slug = filename.replace('.md', '');
+
+          // If it's a new plan, rebuild cache to find its session
+          if (eventType === 'rename' && rebuildPlanCacheCallback) {
+            rebuildPlanCacheCallback();
+          }
+
+          const sessionId = getSessionForPlanCallback ? getSessionForPlanCallback(slug) : null;
+
+          eventBus.emit(EventTypes.PLANS_CHANGED, {
+            type: 'plan',
+            slug,
+            filename,
+            sessionId,
+            directory: PLANS_DIR
+          });
+        }, EVENT_DEBOUNCE_DELAY);
+      }
+    });
+    console.log(`  Watching for plan changes in: ${PLANS_DIR}`);
+  }
+
+  console.log('');
+}
+
+module.exports = {
+  setupWatchers,
+  setPlanCacheCallbacks
+};

package/lib/data/conversation.js

@@ -0,0 +1,195 @@
+/**
+ * Conversation Data Module - Conversation file loading and parsing
+ *
+ * Handles reading conversation files from the Claude projects directory.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { PROJECTS_DIR } = require('../core/config');
+
+/**
+ * Find conversation file for a session
+ * @param {string} sessionId - Session ID
+ * @returns {string|null} Path to conversation file or null
+ */
+function findConversationFile(sessionId) {
+  // Search through all project directories for a matching conversation file
+  if (!fs.existsSync(PROJECTS_DIR)) return null;
+
+  const projectDirs = fs.readdirSync(PROJECTS_DIR);
+  for (const dir of projectDirs) {
+    const conversationPath = path.join(PROJECTS_DIR, dir, `${sessionId}.jsonl`);
+    if (fs.existsSync(conversationPath)) {
+      return conversationPath;
+    }
+  }
+  return null;
+}
+
+/**
+ * Load and parse conversation for a session
+ * @param {string} sessionId - Session ID
+ * @returns {Object} Conversation data with messages array
+ */
+function loadConversation(sessionId) {
+  const filePath = findConversationFile(sessionId);
+  if (!filePath) return { messages: [], found: false };
+
+  try {
+    const fileData = fs.readFileSync(filePath, 'utf-8');
+    const lines = fileData.trim().split('\n');
+    const messages = [];
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+
+        // Skip non-message entries
+        if (!entry.type || !entry.message) continue;
+
+        const msgContent = entry.message.content;
+        const ts = entry.timestamp;
+        const id = entry.uuid;
+
+        if (entry.type === 'user') {
+          // User message: string or array of content blocks
+          if (typeof msgContent === 'string') {
+            messages.push({ id: `user-${id}`, type: 'user', content: msgContent, timestamp: ts });
+          } else if (Array.isArray(msgContent)) {
+            for (let i = 0; i < msgContent.length; i++) {
+              const block = msgContent[i];
+              if (block.type === 'tool_result') {
+                // Tool result response
+                const txt = typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+                messages.push({
+                  id: `result-${block.tool_use_id}`,
+                  type: 'tool_result',
+                  content: txt.length > 200 ? txt.slice(0, 200) + '...' : txt,
+                  timestamp: ts
+                });
+              } else if (block.type === 'text' && block.text) {
+                // User text
+                messages.push({ id: `user-${id}-${i}`, type: 'user', content: block.text, timestamp: ts });
+              }
+            }
+          }
+        } else if (entry.type === 'assistant') {
+          // Assistant message: array of content blocks
+          if (Array.isArray(msgContent)) {
+            for (let i = 0; i < msgContent.length; i++) {
+              const block = msgContent[i];
+              if (block.type === 'text' && block.text) {
+                messages.push({ id: `asst-${id}-${i}`, type: 'assistant', content: block.text, timestamp: ts });
+              } else if (block.type === 'tool_use') {
+                messages.push({
+                  id: `tool-${block.id}`,
+                  type: 'tool_use',
+                  tool: block.name,
+                  input: block.input,
+                  timestamp: ts
+                });
+              }
+            }
+          }
+        }
+      } catch (e) {
+        // Skip malformed lines
+      }
+    }
+
+    return { messages, found: true, path: filePath };
+  } catch (e) {
+    return { messages: [], found: false, error: e.message };
+  }
+}
+
+/**
+ * Get the latest assistant text from a conversation
+ * @param {string} sessionId - Session ID
+ * @returns {string} Latest assistant text or empty string
+ */
+function getLatestAssistantText(sessionId) {
+  const filePath = findConversationFile(sessionId);
+  if (!filePath) return '';
+
+  try {
+    const fileData = fs.readFileSync(filePath, 'utf-8');
+    const lines = fileData.trim().split('\n');
+
+    // Parse backwards to find the most recent assistant text
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        if (entry.type === 'assistant' && Array.isArray(entry.message?.content)) {
+          for (const block of entry.message.content) {
+            if (block.type === 'text' && block.text) {
+              return block.text;
+            }
+          }
+        }
+      } catch (e) {
+        // Skip malformed lines
+      }
+    }
+  } catch (e) {
+    // File read error
+  }
+  return '';
+}
+
+/**
+ * Get session metadata (repo name and first prompt) from conversation
+ * @param {string} sessionId - Session ID
+ * @returns {Object} Metadata with repoName and firstPrompt
+ */
+function getSessionMetadata(sessionId) {
+  const filePath = findConversationFile(sessionId);
+  if (!filePath) return { repoName: null, firstPrompt: null };
+
+  try {
+    // Extract repo name from path
+    const parts = filePath.split(path.sep);
+    const projectsIdx = parts.indexOf('projects');
+    const repoName = projectsIdx >= 0 && parts[projectsIdx + 1] ? parts[projectsIdx + 1] : null;
+
+    // Find first user prompt
+    const fileData = fs.readFileSync(filePath, 'utf-8');
+    const lines = fileData.trim().split('\n');
+    let firstPrompt = null;
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'user' && entry.message?.content) {
+          const content = entry.message.content;
+          if (typeof content === 'string') {
+            firstPrompt = content.substring(0, 200);
+          } else if (Array.isArray(content)) {
+            for (const block of content) {
+              if (block.type === 'text' && block.text) {
+                firstPrompt = block.text.substring(0, 200);
+                break;
+              }
+            }
+          }
+          if (firstPrompt) break;
+        }
+      } catch (e) {
+        // Skip malformed lines
+      }
+    }
+
+    return { repoName, firstPrompt };
+  } catch (e) {
+    return { repoName: null, firstPrompt: null };
+  }
+}
+
+module.exports = {
+  findConversationFile,
+  loadConversation,
+  getLatestAssistantText,
+  getSessionMetadata
+};

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