@cloudstreamsoftware/claude-tools 1.0.0 → 1.1.0

package/dist/lib/session-memory.js

@@ -0,0 +1,489 @@
+/**
+ * Session Memory Store for Real-Time Self-Healing
+ *
+ * Provides in-session learning that persists corrections, preferences,
+ * and effective patterns immediately as they happen - not just at session end.
+ *
+ * This module is the foundation of the real-time self-healing architecture.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getClaudeDir, ensureDir, getDateTimeString } = require('./utils');
+
+// Session memory file path
+const MEMORY_DIR = path.join(getClaudeDir(), 'memory');
+const SESSION_MEMORY_FILE = path.join(MEMORY_DIR, 'current-session.json');
+const KNOWLEDGE_DIR = path.join(getClaudeDir(), 'knowledge');
+
+/**
+ * Default session memory structure
+ */
+function createDefaultMemory() {
+  return {
+    sessionId: generateSessionId(),
+    startedAt: getDateTimeString(),
+    lastUpdated: getDateTimeString(),
+    messageCount: 0,
+
+    // Real-time corrections detected during session
+    corrections: [],
+
+    // User preferences learned during session
+    preferences: {
+      codeStyle: {}, // Formatting, naming preferences
+      tools: {}, // Which tools to use/avoid
+      patterns: {}, // Preferred patterns
+      communication: {}, // How to explain things
+    },
+
+    // Patterns that worked well this session
+    effectivePatterns: [],
+
+    // Anti-patterns detected (things that failed)
+    antiPatterns: [],
+
+    // Context for skill matching
+    context: {
+      files: [], // Files being worked on
+      technologies: [], // Technologies detected (zoho, gcp, react, etc.)
+      complianceMode: null, // HIPAA, SOC2, PCI-DSS, or null
+    },
+  };
+}
+
+/**
+ * Generate a unique session ID
+ */
+function generateSessionId() {
+  const now = new Date();
+  const date = now.toISOString().split('T')[0];
+  const random = Math.random().toString(36).substring(2, 8);
+  return `session-${date}-${random}`;
+}
+
+/**
+ * Load current session memory (or create new)
+ */
+function loadSessionMemory() {
+  ensureDir(MEMORY_DIR);
+
+  try {
+    if (fs.existsSync(SESSION_MEMORY_FILE)) {
+      const data = fs.readFileSync(SESSION_MEMORY_FILE, 'utf8');
+      return JSON.parse(data);
+    }
+  } catch (err) {
+    // If corrupted, start fresh
+    console.error(`[SessionMemory] Error loading memory: ${err.message}`);
+  }
+
+  return createDefaultMemory();
+}
+
+/**
+ * Save session memory to disk
+ */
+function saveSessionMemory(memory) {
+  ensureDir(MEMORY_DIR);
+  memory.lastUpdated = getDateTimeString();
+
+  try {
+    fs.writeFileSync(SESSION_MEMORY_FILE, JSON.stringify(memory, null, 2), 'utf8');
+    return true;
+  } catch (err) {
+    console.error(`[SessionMemory] Error saving memory: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Record a user correction
+ * @param {object} correction - { category, original, corrected, context }
+ */
+function recordCorrection(correction) {
+  const memory = loadSessionMemory();
+
+  const record = {
+    timestamp: getDateTimeString(),
+    category: correction.category || 'general',
+    original: correction.original,
+    corrected: correction.corrected,
+    context: correction.context || null,
+    count: 1,
+  };
+
+  // Check if similar correction exists (merge if so)
+  const existingIndex = memory.corrections.findIndex(
+    (c) => c.category === record.category && c.original === record.original
+  );
+
+  if (existingIndex >= 0) {
+    memory.corrections[existingIndex].count++;
+    memory.corrections[existingIndex].timestamp = record.timestamp;
+  } else {
+    memory.corrections.push(record);
+  }
+
+  saveSessionMemory(memory);
+
+  return record;
+}
+
+/**
+ * Record a user preference
+ * @param {string} category - 'codeStyle', 'tools', 'patterns', 'communication'
+ * @param {string} key - Preference key
+ * @param {any} value - Preference value
+ */
+function recordPreference(category, key, value) {
+  const memory = loadSessionMemory();
+
+  if (memory.preferences[category]) {
+    memory.preferences[category][key] = {
+      value,
+      recordedAt: getDateTimeString(),
+    };
+    saveSessionMemory(memory);
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Record an effective pattern (something that worked well)
+ * @param {object} pattern - { name, description, usage, outcome }
+ */
+function recordEffectivePattern(pattern) {
+  const memory = loadSessionMemory();
+
+  const record = {
+    timestamp: getDateTimeString(),
+    name: pattern.name,
+    description: pattern.description || '',
+    usage: pattern.usage || '',
+    outcome: pattern.outcome || 'success',
+    count: 1,
+  };
+
+  // Check if pattern already exists
+  const existingIndex = memory.effectivePatterns.findIndex((p) => p.name === record.name);
+
+  if (existingIndex >= 0) {
+    memory.effectivePatterns[existingIndex].count++;
+    memory.effectivePatterns[existingIndex].timestamp = record.timestamp;
+  } else {
+    memory.effectivePatterns.push(record);
+  }
+
+  saveSessionMemory(memory);
+
+  return record;
+}
+
+/**
+ * Record an anti-pattern (something that failed)
+ * @param {object} pattern - { name, description, error, avoidance }
+ */
+function recordAntiPattern(pattern) {
+  const memory = loadSessionMemory();
+
+  const record = {
+    timestamp: getDateTimeString(),
+    name: pattern.name,
+    description: pattern.description || '',
+    error: pattern.error || '',
+    avoidance: pattern.avoidance || '',
+    count: 1,
+  };
+
+  // Check if anti-pattern already exists
+  const existingIndex = memory.antiPatterns.findIndex((p) => p.name === record.name);
+
+  if (existingIndex >= 0) {
+    memory.antiPatterns[existingIndex].count++;
+    memory.antiPatterns[existingIndex].timestamp = record.timestamp;
+  } else {
+    memory.antiPatterns.push(record);
+  }
+
+  saveSessionMemory(memory);
+
+  return record;
+}
+
+/**
+ * Update session context
+ * @param {object} context - { files, technologies, complianceMode }
+ */
+function updateContext(context) {
+  const memory = loadSessionMemory();
+
+  if (context.files) {
+    // Add unique files
+    const existingFiles = new Set(memory.context.files);
+    context.files.forEach((f) => existingFiles.add(f));
+    memory.context.files = Array.from(existingFiles);
+  }
+
+  if (context.technologies) {
+    // Add unique technologies
+    const existingTech = new Set(memory.context.technologies);
+    context.technologies.forEach((t) => existingTech.add(t));
+    memory.context.technologies = Array.from(existingTech);
+  }
+
+  if (context.complianceMode) {
+    memory.context.complianceMode = context.complianceMode;
+  }
+
+  saveSessionMemory(memory);
+
+  return memory.context;
+}
+
+/**
+ * Increment message count
+ */
+function incrementMessageCount() {
+  const memory = loadSessionMemory();
+  memory.messageCount++;
+  saveSessionMemory(memory);
+  return memory.messageCount;
+}
+
+/**
+ * Get corrections by category
+ * @param {string} category - Optional category filter
+ */
+function getCorrections(category = null) {
+  const memory = loadSessionMemory();
+
+  if (category) {
+    return memory.corrections.filter((c) => c.category === category);
+  }
+
+  return memory.corrections;
+}
+
+/**
+ * Get preferences by category
+ * @param {string} category - Optional category filter
+ */
+function getPreferences(category = null) {
+  const memory = loadSessionMemory();
+
+  if (category && memory.preferences[category]) {
+    return memory.preferences[category];
+  }
+
+  return memory.preferences;
+}
+
+/**
+ * Check if a specific correction has been made before
+ * @param {string} category - Correction category
+ * @param {string} original - Original behavior to check
+ */
+function hasCorrection(category, original) {
+  const corrections = getCorrections(category);
+  return corrections.find((c) => c.original === original) || null;
+}
+
+/**
+ * Get session summary for learning extraction
+ */
+function getSessionSummary() {
+  const memory = loadSessionMemory();
+
+  return {
+    sessionId: memory.sessionId,
+    duration: calculateDuration(memory.startedAt, memory.lastUpdated),
+    messageCount: memory.messageCount,
+    correctionCount: memory.corrections.length,
+    effectivePatternCount: memory.effectivePatterns.length,
+    antiPatternCount: memory.antiPatterns.length,
+    technologies: memory.context.technologies,
+    complianceMode: memory.context.complianceMode,
+
+    // High-value corrections (count >= 2)
+    frequentCorrections: memory.corrections.filter((c) => c.count >= 2),
+
+    // Patterns worth extracting
+    valuablePatterns: memory.effectivePatterns.filter((p) => p.count >= 2),
+  };
+}
+
+/**
+ * Calculate duration between two datetime strings
+ */
+function calculateDuration(start, end) {
+  try {
+    const startDate = new Date(start.replace(' ', 'T'));
+    const endDate = new Date(end.replace(' ', 'T'));
+    const diffMs = endDate - startDate;
+
+    const hours = Math.floor(diffMs / (1000 * 60 * 60));
+    const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60));
+
+    if (hours > 0) {
+      return `${hours}h ${minutes}m`;
+    }
+    return `${minutes}m`;
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Archive current session to knowledge directory
+ * Called at session end to persist learnings
+ */
+function archiveSession() {
+  const memory = loadSessionMemory();
+  const summary = getSessionSummary();
+
+  ensureDir(KNOWLEDGE_DIR);
+
+  // Archive the session
+  const archivePath = path.join(KNOWLEDGE_DIR, 'sessions', `${memory.sessionId}.json`);
+  ensureDir(path.dirname(archivePath));
+
+  try {
+    fs.writeFileSync(
+      archivePath,
+      JSON.stringify(
+        {
+          ...memory,
+          summary,
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    // Clear current session memory for next session
+    fs.unlinkSync(SESSION_MEMORY_FILE);
+
+    return { success: true, archivePath, summary };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Merge corrections into the persistent anti-patterns knowledge base
+ * Called during session aggregation
+ */
+function mergeCorrectionsToKnowledge() {
+  ensureDir(KNOWLEDGE_DIR);
+
+  const antiPatternsFile = path.join(KNOWLEDGE_DIR, 'anti-patterns.json');
+  const memory = loadSessionMemory();
+
+  // Load existing anti-patterns
+  let antiPatterns = { patterns: [], lastUpdated: null };
+  try {
+    if (fs.existsSync(antiPatternsFile)) {
+      antiPatterns = JSON.parse(fs.readFileSync(antiPatternsFile, 'utf8'));
+    }
+  } catch {
+    // Start fresh if corrupted
+  }
+
+  // Merge corrections with count >= 2 (significant corrections)
+  const significantCorrections = memory.corrections.filter((c) => c.count >= 2);
+
+  for (const correction of significantCorrections) {
+    const existingIndex = antiPatterns.patterns.findIndex(
+      (p) => p.category === correction.category && p.original === correction.original
+    );
+
+    if (existingIndex >= 0) {
+      antiPatterns.patterns[existingIndex].totalCount += correction.count;
+      antiPatterns.patterns[existingIndex].sessions++;
+      antiPatterns.patterns[existingIndex].lastSeen = getDateTimeString();
+    } else {
+      antiPatterns.patterns.push({
+        category: correction.category,
+        original: correction.original,
+        corrected: correction.corrected,
+        context: correction.context,
+        totalCount: correction.count,
+        sessions: 1,
+        firstSeen: getDateTimeString(),
+        lastSeen: getDateTimeString(),
+      });
+    }
+  }
+
+  antiPatterns.lastUpdated = getDateTimeString();
+
+  try {
+    fs.writeFileSync(antiPatternsFile, JSON.stringify(antiPatterns, null, 2), 'utf8');
+    return { success: true, merged: significantCorrections.length };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Get known anti-patterns from knowledge base
+ * Used by hooks to prevent repeating mistakes
+ */
+function getKnownAntiPatterns() {
+  const antiPatternsFile = path.join(KNOWLEDGE_DIR, 'anti-patterns.json');
+
+  try {
+    if (fs.existsSync(antiPatternsFile)) {
+      const data = JSON.parse(fs.readFileSync(antiPatternsFile, 'utf8'));
+      return data.patterns || [];
+    }
+  } catch {
+    // Return empty if not found or corrupted
+  }
+
+  return [];
+}
+
+/**
+ * Reset session memory (for testing or forced reset)
+ */
+function resetSession() {
+  const newMemory = createDefaultMemory();
+  saveSessionMemory(newMemory);
+  return newMemory;
+}
+
+module.exports = {
+  // Core operations
+  loadSessionMemory,
+  saveSessionMemory,
+  resetSession,
+
+  // Recording functions
+  recordCorrection,
+  recordPreference,
+  recordEffectivePattern,
+  recordAntiPattern,
+  updateContext,
+  incrementMessageCount,
+
+  // Query functions
+  getCorrections,
+  getPreferences,
+  hasCorrection,
+  getSessionSummary,
+
+  // Persistence
+  archiveSession,
+  mergeCorrectionsToKnowledge,
+  getKnownAntiPatterns,
+
+  // Constants
+  MEMORY_DIR,
+  SESSION_MEMORY_FILE,
+  KNOWLEDGE_DIR,
+};