chati-dev 4.0.11 → 4.1.1

package/src/memory/dream.js

@@ -0,0 +1,254 @@
+/**
+ * Dream — Memory Consolidation System.
+ *
+ * 4-phase consolidation inspired by Claude Code's autoDream:
+ *   Phase 1 (Orient):      Scan existing memories, assess landscape
+ *   Phase 2 (Gather):      Read all agent memories and session digests
+ *   Phase 3 (Consolidate): Deduplicate, merge cross-agent, increment evidence
+ *   Phase 4 (Prune):       Remove cold/low-confidence entries, archive removed
+ *
+ * Triggered manually via `/chati dream` or programmatically.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import { readAgentMemory, getAgentMemoryStats } from './agent-memory.js';
+
+const MAX_ENTRIES = 200;
+const MEMORY_BASE = '.chati/memories';
+const ARCHIVE_DIR = '.chati/memories/shared/archive';
+
+/**
+ * Run the complete 4-phase dream consolidation.
+ * @param {string} projectDir - Project root directory
+ * @returns {{ phase1: object, phase2: object, phase3: object, phase4: object, summary: object }}
+ */
+export function runDreamConsolidation(projectDir) {
+  const report = {
+    phase1: null,
+    phase2: null,
+    phase3: null,
+    phase4: null,
+    summary: { merged: 0, pruned: 0, archived: 0, remaining: 0, contradictions: 0 },
+  };
+
+  // Phase 1: Orient
+  report.phase1 = orient(projectDir);
+
+  // Phase 2: Gather
+  report.phase2 = gather(projectDir, report.phase1.agents);
+
+  // Phase 3: Consolidate
+  report.phase3 = consolidate(report.phase2.allEntries);
+
+  // Phase 4: Prune
+  report.phase4 = prune(projectDir, report.phase3.consolidated);
+
+  // Summary
+  report.summary = {
+    merged: report.phase3.mergedCount,
+    pruned: report.phase4.prunedCount,
+    archived: report.phase4.archivedCount,
+    remaining: report.phase4.remaining,
+    contradictions: report.phase3.contradictions,
+    timestamp: new Date().toISOString(),
+  };
+
+  return report;
+}
+
+/**
+ * Phase 1: Orient — Scan memory landscape.
+ */
+function orient(projectDir) {
+  const stats = getAgentMemoryStats(projectDir);
+  const memoryBase = join(projectDir, MEMORY_BASE);
+
+  // Count shared memories
+  let sharedCount = 0;
+  const sharedDir = join(memoryBase, 'shared');
+  if (existsSync(sharedDir)) {
+    try {
+      const gotchasPath = join(sharedDir, 'gotchas.json');
+      if (existsSync(gotchasPath)) {
+        const data = JSON.parse(readFileSync(gotchasPath, 'utf-8'));
+        sharedCount = Array.isArray(data) ? data.length : (data.gotchas || []).length;
+      }
+    } catch (err) { process.stderr.write(`[chati] dream orient gotchas: ${err.message}\n`); }
+  }
+
+  // List agents with memories
+  const agents = [];
+  const agentsDir = join(memoryBase);
+  if (existsSync(agentsDir)) {
+    try {
+      const dirs = readdirSync(agentsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && d.name !== 'shared')
+        .map(d => d.name);
+      for (const agentName of dirs) {
+        const memPath = join(agentsDir, agentName, 'MEMORY.md');
+        if (existsSync(memPath)) {
+          agents.push(agentName);
+        }
+      }
+    } catch (err) { process.stderr.write(`[chati] dream orient agents: ${err.message}\n`); }
+  }
+
+  return {
+    totalAgents: agents.length,
+    agents,
+    agentStats: stats,
+    sharedGotchas: sharedCount,
+  };
+}
+
+/**
+ * Phase 2: Gather — Read all agent memories into unified list.
+ */
+function gather(projectDir, agentNames) {
+  const allEntries = [];
+
+  for (const agentName of agentNames) {
+    const memResult = readAgentMemory(projectDir, agentName);
+    if (memResult.loaded && memResult.entries) {
+      for (const entry of memResult.entries) {
+        allEntries.push({
+          ...entry,
+          agent: agentName,
+          _hash: hashContent(entry.content || ''),
+        });
+      }
+    }
+  }
+
+  return {
+    totalEntries: allEntries.length,
+    byAgent: agentNames.reduce((acc, name) => {
+      acc[name] = allEntries.filter(e => e.agent === name).length;
+      return acc;
+    }, {}),
+    allEntries,
+  };
+}
+
+/**
+ * Phase 3: Consolidate — Deduplicate and merge.
+ */
+function consolidate(allEntries) {
+  const hashMap = new Map();
+  let mergedCount = 0;
+  let contradictions = 0;
+
+  for (const entry of allEntries) {
+    const existing = hashMap.get(entry._hash);
+    if (existing) {
+      // Merge: keep highest confidence, combine tags, increment evidence
+      mergedCount++;
+      existing.confidence = Math.max(existing.confidence || 0, entry.confidence || 0);
+      existing.evidence_count = (existing.evidence_count || 1) + (entry.evidence_count || 1);
+
+      // Merge tags
+      const existingTags = new Set(existing.tags || []);
+      for (const tag of (entry.tags || [])) {
+        existingTags.add(tag);
+      }
+      existing.tags = [...existingTags];
+
+      // Track cross-agent corroboration
+      if (entry.agent !== existing.agent) {
+        existing.scope = 'shared';
+        if (!existing._agents) existing._agents = new Set([existing.agent]);
+        existing._agents.add(entry.agent);
+      }
+    } else {
+      hashMap.set(entry._hash, { ...entry });
+    }
+  }
+
+  const consolidated = [...hashMap.values()];
+
+  // Detect contradictions: entries from same agent with same type but different content
+  const agentTypeMap = new Map();
+  for (const entry of consolidated) {
+    const key = `${entry.agent}:${entry.type || entry.category || 'unknown'}`;
+    const existing = agentTypeMap.get(key);
+    if (existing && existing._hash !== entry._hash) {
+      contradictions++;
+    }
+    agentTypeMap.set(key, entry);
+  }
+
+  const cleaned = consolidated.map(({ _hash: _h, _agents: _a, ...clean }) => clean);
+
+  return {
+    consolidated: cleaned,
+    mergedCount,
+    contradictions,
+    uniqueCount: cleaned.length,
+  };
+}
+
+/**
+ * Phase 4: Prune — Remove cold entries if over MAX_ENTRIES, archive removed.
+ */
+function prune(projectDir, consolidated) {
+  if (consolidated.length <= MAX_ENTRIES) {
+    return {
+      prunedCount: 0,
+      archivedCount: 0,
+      remaining: consolidated.length,
+    };
+  }
+
+  // Sort: cold first, then lowest confidence, then lowest access_count
+  const tierOrder = { cold: 0, warm: 1, hot: 2 };
+  const sorted = [...consolidated].sort((a, b) => {
+    const tierDiff = (tierOrder[a.tier] || 0) - (tierOrder[b.tier] || 0);
+    if (tierDiff !== 0) return tierDiff;
+    const confDiff = (a.confidence || 0) - (b.confidence || 0);
+    if (confDiff !== 0) return confDiff;
+    return (a.access_count || 0) - (b.access_count || 0);
+  });
+
+  const toRemove = sorted.slice(0, sorted.length - MAX_ENTRIES);
+  const toKeep = sorted.slice(sorted.length - MAX_ENTRIES);
+
+  // Archive removed entries
+  let archivedCount = 0;
+  if (toRemove.length > 0) {
+    const archiveDir = join(projectDir, ARCHIVE_DIR);
+    mkdirSync(archiveDir, { recursive: true });
+
+    const dateStr = new Date().toISOString().split('T')[0];
+    const archivePath = join(archiveDir, `dream-${dateStr}.json`);
+
+    try {
+      let existing = [];
+      if (existsSync(archivePath)) {
+        existing = JSON.parse(readFileSync(archivePath, 'utf-8'));
+      }
+      const merged = [...existing, ...toRemove];
+      writeFileSync(archivePath, JSON.stringify(merged, null, 2), 'utf-8');
+      archivedCount = toRemove.length;
+    } catch (err) { process.stderr.write(`[chati] dream prune archive: ${err.message}\n`); }
+  }
+
+  return {
+    prunedCount: toRemove.length,
+    archivedCount,
+    remaining: toKeep.length,
+  };
+}
+
+/**
+ * Hash content for deduplication (same approach as gotchas.js).
+ */
+function hashContent(text) {
+  const normalized = String(text)
+    .toLowerCase()
+    .replace(/\s+/g, ' ')
+    .replace(/\d+/g, 'N')
+    .trim();
+  return createHash('sha256').update(normalized).digest('hex').slice(0, 16);
+}

package/src/memory/gotchas.js

@@ -104,7 +104,7 @@ function loadGotchas(projectDir) {
   try {
     const content = readFileSync(gotchasPath, 'utf-8');
     return JSON.parse(content);
-  } catch {
+  } catch { /* expected: file may not exist */
     return [];
   }
 }
@@ -136,7 +136,7 @@ function loadErrorLog(projectDir) {
   try {
     const content = readFileSync(errorLogPath, 'utf-8');
     return JSON.parse(content);
-  } catch {
+  } catch { /* expected: file may not exist */
     return [];
   }
 }

package/src/memory/index.js

@@ -33,3 +33,21 @@ export {
   searchAllMemories,
   getUnifiedMemoryStats,
 } from './search.js';
+
+export {
+  extractMemories,
+  getExtractionStats,
+} from './memory-extractor.js';
+
+export { runDreamConsolidation } from './dream.js';
+
+export { updateClaudeMd } from './magic-docs.js';
+
+export { buildStructuredDigest } from './session-digest.js';
+
+export {
+  buildDailyEntry,
+  appendDailyDigest,
+  loadTodayDigest,
+  loadDigestByDate,
+} from './daily-digest.js';

package/src/memory/magic-docs.js

@@ -0,0 +1,98 @@
+/**
+ * Magic Docs — Auto-updating CLAUDE.md after agent handoffs.
+ *
+ * Inspired by Claude Code's Magic Docs system that uses `# MAGIC DOC:` headers
+ * to trigger background self-updating documentation.
+ *
+ * This module updates only the `## Current State` section of CLAUDE.md,
+ * preserving all other user-written sections untouched.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const SECTION_HEADER = '## Current State';
+const SECTION_REGEX = /^## Current State\n([\s\S]*?)(?=\n## |\n---|\n$|$)/m;
+
+/**
+ * Update CLAUDE.md with current project state after a handoff.
+ *
+ * @param {string} projectDir - Project root directory
+ * @param {object} context - Current state to write
+ * @param {string} [context.currentAgent] - Active agent name
+ * @param {string} [context.pipelinePosition] - Pipeline phase/step
+ * @param {string} [context.activeTask] - Current task ID + title
+ * @param {number} [context.progress] - Pipeline completion percentage
+ * @param {Array<{what: string, why: string}>} [context.decisions] - Recent decisions
+ * @param {string[]} [context.nextSteps] - Planned next steps
+ * @returns {{ updated: boolean, path: string }}
+ */
+export function updateClaudeMd(projectDir, context = {}) {
+  const claudePath = join(projectDir, 'CLAUDE.md');
+  const timestamp = new Date().toISOString().split('T')[0];
+
+  // Build the new section content
+  const lines = [];
+  lines.push(SECTION_HEADER);
+  if (context.currentAgent) lines.push(`- **Agent**: ${context.currentAgent}`);
+  if (context.pipelinePosition) lines.push(`- **Pipeline**: ${context.pipelinePosition}`);
+  if (context.activeTask) lines.push(`- **Task**: ${context.activeTask}`);
+  if (context.progress !== undefined) lines.push(`- **Progress**: ${context.progress}%`);
+  lines.push(`- **Last Updated**: ${timestamp}`);
+
+  if (context.decisions && context.decisions.length > 0) {
+    lines.push('');
+    lines.push('### Recent Decisions');
+    for (const d of context.decisions.slice(0, 5)) {
+      const text = typeof d === 'object' ? `${d.what} — ${d.why}` : String(d);
+      lines.push(`- ${text}`);
+    }
+  }
+
+  if (context.nextSteps && context.nextSteps.length > 0) {
+    lines.push('');
+    lines.push('### Next Steps');
+    for (const step of context.nextSteps.slice(0, 5)) {
+      lines.push(`- ${step}`);
+    }
+  }
+
+  const newSection = lines.join('\n');
+
+  try {
+    if (!existsSync(claudePath)) {
+      // Create CLAUDE.md with just the Current State section
+      writeFileSync(claudePath, newSection + '\n', 'utf-8');
+      return { updated: true, path: claudePath };
+    }
+
+    const content = readFileSync(claudePath, 'utf-8');
+
+    // Handle empty file as creation
+    if (!content || content.trim().length === 0) {
+      writeFileSync(claudePath, newSection + '\n', 'utf-8');
+      return { updated: true, path: claudePath };
+    }
+
+    let updatedContent;
+    if (SECTION_REGEX.test(content)) {
+      // Replace existing section
+      updatedContent = content.replace(SECTION_REGEX, newSection);
+    } else {
+      // Find insertion point — after first heading or at the top
+      const firstHeadingEnd = content.indexOf('\n## ');
+      if (firstHeadingEnd !== -1) {
+        // Insert before the first ## section
+        updatedContent = content.slice(0, firstHeadingEnd) + '\n\n' + newSection + '\n' + content.slice(firstHeadingEnd);
+      } else {
+        // Append at end
+        updatedContent = content.trimEnd() + '\n\n' + newSection + '\n';
+      }
+    }
+
+    writeFileSync(claudePath, updatedContent, 'utf-8');
+    return { updated: true, path: claudePath };
+  } catch { /* expected: operation may fail gracefully */
+    return { updated: false, path: claudePath };
+  }
+}

package/src/memory/memory-extractor.js

@@ -0,0 +1,163 @@
+/**
+ * Memory Extractor — Per-turn automatic memory capture.
+ *
+ * Analyzes agent output text for patterns indicating decisions, resolutions,
+ * corrections, and validated patterns. Extracts up to MAX_PER_TURN memories
+ * following the memory.schema.json structure.
+ *
+ * Inspired by Claude Code's extractMemories system that runs as a forked
+ * agent after each complete turn.
+ */
+
+const MAX_PER_TURN = 3;
+
+/**
+ * Extraction patterns mapped to memory types and cognitive sectors.
+ * Each pattern has: regex, memory type, cognitive sector, confidence base.
+ */
+const EXTRACTION_PATTERNS = [
+  // Decisions — episodic sector
+  {
+    patterns: [
+      /(?:decided|chose|selected|picked|went with|opted for)\s+(?:to\s+)?(.{10,120})/gi,
+      /(?:decision|choice):\s*(.{10,120})/gi,
+    ],
+    type: 'decision',
+    sector: 'episodic',
+    confidence: 0.6,
+  },
+  // Resolutions — procedural sector
+  {
+    patterns: [
+      /(?:fixed|resolved|solved|patched|workaround)\s+(?:by|with|via)\s+(.{10,120})/gi,
+      /(?:solution|fix|resolution):\s*(.{10,120})/gi,
+    ],
+    type: 'resolution',
+    sector: 'procedural',
+    confidence: 0.7,
+  },
+  // User corrections — reflective sector
+  {
+    patterns: [
+      /(?:actually|no,?\s+use|instead,?\s+use|correction:)\s+(.{10,120})/gi,
+      /(?:user\s+(?:said|wants|prefers|corrected)):?\s*(.{10,120})/gi,
+    ],
+    type: 'user_correction',
+    sector: 'reflective',
+    confidence: 0.8,
+  },
+  // Validated patterns — semantic sector
+  {
+    patterns: [
+      /(?:confirmed|verified|validated|works|proven)\s+(?:that\s+)?(.{10,120})/gi,
+      /(?:pattern|approach)\s+(?:works|validated|confirmed):\s*(.{10,120})/gi,
+    ],
+    type: 'validated_pattern',
+    sector: 'semantic',
+    confidence: 0.6,
+  },
+  // Error patterns — episodic sector
+  {
+    patterns: [
+      /(?:error|bug|issue|problem):\s*(.{10,120})/gi,
+      /(?:failed|broke|crashed)\s+(?:because|due to|when)\s+(.{10,120})/gi,
+    ],
+    type: 'error_pattern',
+    sector: 'episodic',
+    confidence: 0.5,
+  },
+];
+
+/**
+ * Extract memories from agent output text.
+ *
+ * @param {string} text - Agent response text to analyze
+ * @param {object} context - Current execution context
+ * @param {string} context.agent - Active agent name
+ * @param {string} [context.task] - Active task ID
+ * @param {string} [context.mode] - Current mode
+ * @returns {object[]} Array of memory candidates (max MAX_PER_TURN)
+ */
+export function extractMemories(text, context = {}) {
+  if (!text || typeof text !== 'string' || text.length < 20) return [];
+
+  const candidates = [];
+  const seen = new Set();
+
+  for (const group of EXTRACTION_PATTERNS) {
+    for (const pattern of group.patterns) {
+      // Create fresh regex to avoid shared lastIndex state across calls
+      const re = new RegExp(pattern.source, pattern.flags);
+      let match;
+      while ((match = re.exec(text)) !== null) {
+        const content = (match[1] || '').trim();
+        if (!content || content.length < 10) continue;
+
+        // Deduplicate by normalized content
+        const normalized = content.toLowerCase().replace(/\s+/g, ' ');
+        if (seen.has(normalized)) continue;
+        seen.add(normalized);
+
+        candidates.push({
+          content,
+          type: group.type,
+          sector: group.sector,
+          confidence: group.confidence,
+        });
+      }
+    }
+  }
+
+  // Sort by confidence (highest first), take top N
+  candidates.sort((a, b) => b.confidence - a.confidence);
+  const selected = candidates.slice(0, MAX_PER_TURN);
+
+  // Build memory entries following memory.schema.json
+  const now = new Date().toISOString();
+  return selected.map((candidate, i) => ({
+    id: `mem-${now.split('T')[0]}-${String(i + 1).padStart(3, '0')}`,
+    type: candidate.type,
+    agent: context.agent || 'unknown',
+    content: candidate.content,
+    tags: buildTags(candidate.content, context),
+    confidence: candidate.confidence,
+    sector: candidate.sector,
+    tier: candidate.confidence >= 0.7 ? 'hot' : 'warm',
+    access_count: 0,
+    evidence_count: 1,
+    last_accessed: null,
+    created_at: now,
+    expires_at: null,
+    storage_tier: 'daily',
+    scope: 'shared',
+  }));
+}
+
+/**
+ * Build tags from memory content and context.
+ */
+function buildTags(content, context) {
+  const tags = [];
+  if (context.agent) tags.push(context.agent);
+  if (context.task) tags.push(context.task);
+
+  // Extract technology keywords
+  const techPatterns = /\b(react|next|vue|angular|supabase|postgres|typescript|node|express|tailwind|prisma|zod|jwt|auth|api|css|html)\b/gi;
+  const techMatches = content.match(techPatterns) || [];
+  for (const tech of [...new Set(techMatches.map(t => t.toLowerCase()))]) {
+    if (!tags.includes(tech)) tags.push(tech);
+  }
+
+  return tags.length > 0 ? tags : ['general'];
+}
+
+/**
+ * Get extraction statistics for monitoring.
+ */
+export function getExtractionStats() {
+  return {
+    maxPerTurn: MAX_PER_TURN,
+    patternGroups: EXTRACTION_PATTERNS.length,
+    totalPatterns: EXTRACTION_PATTERNS.reduce((sum, g) => sum + g.patterns.length, 0),
+  };
+}