claude-multi-session 1.0.1 → 2.3.0

package/src/decision-journal.js

@@ -0,0 +1,229 @@
+/**
+ * Decision Journal — tracks architectural decisions, choices, and rationale
+ * Part of the Session Continuity Engine (Layer 0)
+ *
+ * This module helps maintain a record of important decisions made during
+ * development, including the reasoning behind them. This helps future sessions
+ * understand why certain choices were made.
+ *
+ * Storage: JSONL format (one JSON object per line)
+ * Location: ~/.claude-multi-session/continuity/{projectHash}/journal.jsonl
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { readJsonSafe, appendJsonl } = require('./atomic-io');
+
+/**
+ * DecisionJournal class
+ *
+ * Manages a journal of decisions for a specific project.
+ * Each decision includes:
+ * - What was decided
+ * - Why it was decided
+ * - Related files
+ * - Tags for categorization
+ * - Additional context
+ */
+class DecisionJournal {
+  /**
+   * Create a new Decision Journal
+   *
+   * @param {string} projectPath - Absolute path to the project directory
+   *
+   * The journal is stored in a directory based on a hash of the project path,
+   * so each project gets its own isolated journal.
+   */
+  constructor(projectPath) {
+    // Create a unique hash for this project (16 characters)
+    // This ensures each project has its own journal storage
+    const projectHash = crypto
+      .createHash('sha256')
+      .update(projectPath)
+      .digest('hex')
+      .slice(0, 16);
+
+    // Set up storage directory: ~/.claude-multi-session/continuity/{hash}
+    this.storageDir = path.join(
+      os.homedir(),
+      '.claude-multi-session',
+      'continuity',
+      projectHash
+    );
+
+    // The journal file is a JSONL file (one JSON object per line)
+    this.journalPath = path.join(this.storageDir, 'journal.jsonl');
+
+    // Create the storage directory if it doesn't exist yet
+    if (!fs.existsSync(this.storageDir)) {
+      fs.mkdirSync(this.storageDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Add a new decision to the journal
+   *
+   * @param {Object} params - Decision parameters
+   * @param {string} params.decision - The decision that was made (required)
+   * @param {string} [params.reason] - Why this decision was made
+   * @param {string[]} [params.files] - Related file paths
+   * @param {string[]} [params.tags] - Tags for categorization (e.g., ['auth', 'security'])
+   * @param {string} [params.context] - Additional context or notes
+   * @returns {Object} The created decision entry with ID and timestamp
+   *
+   * Example:
+   *   journal.add({
+   *     decision: 'Use bcrypt for password hashing',
+   *     reason: 'More mature and widely tested than argon2',
+   *     files: ['src/auth.js'],
+   *     tags: ['security', 'auth']
+   *   })
+   */
+  add({ decision, reason, files, tags, context }) {
+    // Generate a unique ID for this decision
+    // Format: d_{timestamp}_{random} (e.g., d_1707840000000_a3f2b1c4)
+    const id = 'd_' + Date.now() + '_' + crypto.randomBytes(4).toString('hex');
+
+    // Build the decision entry
+    const entry = {
+      id,
+      decision,                      // The decision itself (required)
+      reason: reason || '',          // Why it was made (optional)
+      files: files || [],            // Related files (optional)
+      tags: tags || [],              // Tags for filtering (optional)
+      context: context || '',        // Extra context (optional)
+      createdAt: new Date().toISOString()  // When it was created
+    };
+
+    // Append to the journal file (one line per decision)
+    appendJsonl(this.journalPath, entry);
+
+    // Return the entry so the caller knows what was saved
+    return entry;
+  }
+
+  /**
+   * List decisions from the journal
+   *
+   * @param {Object} [options] - Filter and pagination options
+   * @param {number} [options.limit=50] - Maximum number of decisions to return
+   * @param {string} [options.tag] - Only return decisions with this tag
+   * @param {string} [options.since] - Only return decisions after this date (ISO string)
+   * @returns {Object[]} Array of decision entries, newest first
+   *
+   * Example:
+   *   journal.list({ limit: 10, tag: 'auth' })
+   *   journal.list({ since: '2024-01-01T00:00:00Z' })
+   */
+  list({ limit = 50, tag, since } = {}) {
+    // If the journal file doesn't exist yet, return empty array
+    if (!fs.existsSync(this.journalPath)) {
+      return [];
+    }
+
+    // Read the entire journal file
+    const content = fs.readFileSync(this.journalPath, 'utf-8');
+
+    // Parse each line as JSON (JSONL format)
+    const entries = content
+      .split('\n')                    // Split into lines
+      .filter(line => line.trim())   // Remove empty lines
+      .map(line => JSON.parse(line)); // Parse each line as JSON
+
+    // Start with all entries
+    let filtered = entries;
+
+    // Filter by tag if specified
+    if (tag) {
+      filtered = filtered.filter(entry => entry.tags.includes(tag));
+    }
+
+    // Filter by date if specified
+    if (since) {
+      const sinceDate = new Date(since);
+      filtered = filtered.filter(entry => new Date(entry.createdAt) >= sinceDate);
+    }
+
+    // Sort by creation date, newest first
+    // (Reverse because JSONL is in chronological order)
+    filtered.reverse();
+
+    // Return only the requested number of entries
+    return filtered.slice(0, limit);
+  }
+
+  /**
+   * Search for decisions by keyword
+   *
+   * @param {string} keyword - Search term (case-insensitive)
+   * @returns {Object[]} Array of matching decision entries, newest first
+   *
+   * Searches across the decision text, reason, and context fields.
+   *
+   * Example:
+   *   journal.search('bcrypt')
+   *   journal.search('authentication')
+   */
+  search(keyword) {
+    // If the journal file doesn't exist yet, return empty array
+    if (!fs.existsSync(this.journalPath)) {
+      return [];
+    }
+
+    // Read and parse all entries (same as list())
+    const content = fs.readFileSync(this.journalPath, 'utf-8');
+    const entries = content
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => JSON.parse(line));
+
+    // Convert keyword to lowercase for case-insensitive search
+    const searchTerm = keyword.toLowerCase();
+
+    // Find entries where the keyword appears in decision, reason, or context
+    const matches = entries.filter(entry => {
+      return (
+        entry.decision.toLowerCase().includes(searchTerm) ||
+        entry.reason.toLowerCase().includes(searchTerm) ||
+        entry.context.toLowerCase().includes(searchTerm)
+      );
+    });
+
+    // Return matches, newest first
+    return matches.reverse();
+  }
+
+  /**
+   * Get a specific decision by its ID
+   *
+   * @param {string} decisionId - The decision ID to retrieve
+   * @returns {Object|null} The decision entry, or null if not found
+   *
+   * Example:
+   *   journal.get('d_1707840000000_a3f2b1c4')
+   */
+  get(decisionId) {
+    // If the journal file doesn't exist yet, return null
+    if (!fs.existsSync(this.journalPath)) {
+      return null;
+    }
+
+    // Read and parse all entries
+    const content = fs.readFileSync(this.journalPath, 'utf-8');
+    const entries = content
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => JSON.parse(line));
+
+    // Find the entry with matching ID
+    const entry = entries.find(e => e.id === decisionId);
+
+    // Return the entry or null if not found
+    return entry || null;
+  }
+}
+
+// Export the class so other modules can use it
+module.exports = DecisionJournal;

package/src/delegate.js

@@ -119,7 +119,7 @@ class Delegate {
       : null;
 
     // Build the full prompt with context and instructions
-    const fullPrompt = this._buildPrompt(task, options.context);
+    const fullPrompt = this._buildPrompt(task, options.context, name);
 
     // Spawn the session
     let spawnResult;
@@ -248,22 +248,11 @@ class Delegate {
 
   /**
    * Build the full prompt with context and structured output instructions.
+   * Uses the production-quality delegate prompt template from prompts.js.
    */
-  _buildPrompt(task, context) {
-    let prompt = '';
-
-    if (context) {
-      prompt += `CONTEXT:\n${context}\n\n`;
-    }
-
-    prompt += `TASK:\n${task}\n\n`;
-    prompt += `INSTRUCTIONS:\n`;
-    prompt += `- Complete the task thoroughly\n`;
-    prompt += `- If you encounter errors, try to fix them\n`;
-    prompt += `- If you need clarification, say what you need and stop\n`;
-    prompt += `- At the end, provide a brief summary of what you did\n`;
-
-    return prompt;
+  _buildPrompt(task, context, name) {
+    const { buildDelegatePrompt } = require('./prompts');
+    return buildDelegatePrompt(task, context, name);
   }
 
   /**