claudehq 1.0.1 → 1.0.3

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