@jungjaehoon/mama-server 1.0.0

package/src/mama/outcome-tracker.js

@@ -0,0 +1,349 @@
+/**
+ * MAMA (Memory-Augmented MCP Architecture) - Outcome Tracker
+ *
+ * Track decision outcomes from user feedback
+ * Tasks: 4.1-4.8 (Failure/success indicators, UserPromptSubmit analysis, outcome marking)
+ * AC #3: Failure tracking (user feedback → outcome marked, failure_reason extracted, duration calculated)
+ *
+ * @module outcome-tracker
+ * @version 1.0
+ * @date 2025-11-14
+ */
+
+const { info, error: logError } = require('./debug-logger');
+const { getDB, updateDecisionOutcome } = require('./memory-store');
+const { updateConfidence } = require('./decision-tracker');
+
+/**
+ * Failure indicators
+ * Task 4.2: Define failure indicators
+ */
+const FAILURE_INDICATORS = [
+  /doesn't\s*work/i,
+  /failed/i,
+  /error/i,
+  /slow/i,
+  /broken/i,
+  /bug/i,
+  /wrong/i,
+  /not\s*working/i,
+];
+
+/**
+ * Success indicators
+ * Task 4.3: Define success indicators
+ */
+const SUCCESS_INDICATORS = [
+  /works/i,
+  /perfect/i,
+  /great/i,
+  /success/i,
+  /excellent/i,
+  /fast/i,
+  /good/i,
+];
+
+/**
+ * Partial success indicators
+ * Task 4.3: Define partial success indicators
+ */
+const PARTIAL_INDICATORS = [
+  /okay/i,
+  /acceptable/i,
+  /improved/i,
+  /better/i,
+];
+
+/**
+ * Recent decision time window (1 hour in milliseconds)
+ * Task 4.5: Only mark outcome if decision is recent (< 1 hour)
+ */
+const RECENT_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+
+/**
+ * Check if message matches failure indicators
+ *
+ * Task 4.2: Match failure patterns
+ *
+ * @param {string} message - User message
+ * @returns {boolean} True if failure detected
+ */
+function matchesFailureIndicators(message) {
+  return FAILURE_INDICATORS.some((pattern) => pattern.test(message));
+}
+
+/**
+ * Check if message matches success indicators
+ *
+ * Task 4.3: Match success patterns
+ *
+ * @param {string} message - User message
+ * @returns {boolean} True if success detected
+ */
+function matchesSuccessIndicators(message) {
+  return SUCCESS_INDICATORS.some((pattern) => pattern.test(message));
+}
+
+/**
+ * Check if message matches partial success indicators
+ *
+ * Task 4.3: Match partial success patterns
+ *
+ * @param {string} message - User message
+ * @returns {boolean} True if partial success detected
+ */
+function matchesPartialIndicators(message) {
+  return PARTIAL_INDICATORS.some((pattern) => pattern.test(message));
+}
+
+/**
+ * Determine outcome from user message
+ *
+ * Task 4.4, 4.5: Analyze user message for indicators
+ * AC #3: Failure tracking from user feedback
+ *
+ * @param {string} message - User message
+ * @returns {string|null} Outcome type ('FAILED', 'SUCCESS', 'PARTIAL') or null
+ */
+function analyzeOutcome(message) {
+  if (matchesFailureIndicators(message)) {
+    return 'FAILED';
+  }
+
+  if (matchesSuccessIndicators(message)) {
+    return 'SUCCESS';
+  }
+
+  if (matchesPartialIndicators(message)) {
+    return 'PARTIAL';
+  }
+
+  return null; // No clear outcome
+}
+
+/**
+ * Extract failure reason from user message
+ *
+ * Task 4.6: Extract failure_reason from user message
+ * AC #3: failure_reason extracted
+ *
+ * Simple extraction: First sentence or first 200 characters
+ * Future: Use LLM for better extraction
+ *
+ * @param {string} message - User message
+ * @param {string} outcome - Outcome type
+ * @returns {string|null} Failure reason
+ */
+function extractFailureReason(message, outcome) {
+  if (outcome !== 'FAILED') {
+    return null;
+  }
+
+  // Extract first sentence
+  const firstSentence = message.split(/[.!?]/)[0].trim();
+
+  // Limit to 200 characters
+  const reason = firstSentence.substring(0, 200);
+
+  return reason || 'User indicated failure';
+}
+
+/**
+ * Get recent decision (within 1 hour)
+ *
+ * Task 4.5: Find recent decision (< 1 hour)
+ * AC #3: Recent decision (< 1 hour) marked
+ *
+ * @param {string} sessionId - Session ID
+ * @returns {Object|null} Recent decision or null
+ */
+function getRecentDecision(sessionId) {
+  const db = getDB();
+
+  try {
+    const now = Date.now();
+    const cutoffTime = now - RECENT_WINDOW_MS;
+
+    const recent = db
+      .prepare(
+        `
+      SELECT * FROM decisions
+      WHERE session_id = ?
+        AND outcome IS NULL
+        AND created_at > ?
+      ORDER BY created_at DESC
+      LIMIT 1
+    `
+      )
+      .get(sessionId, cutoffTime);
+
+    return recent || null;
+  } catch (error) {
+    throw new Error(`Failed to query recent decision: ${error.message}`);
+  }
+}
+
+/**
+ * Calculate duration in days
+ *
+ * Task 4.7: Calculate duration_days
+ * AC #3: duration_days calculated
+ *
+ * @param {number} createdAt - Decision created timestamp
+ * @returns {number} Duration in days
+ */
+function calculateDurationDays(createdAt) {
+  const now = Date.now();
+  const durationMs = now - createdAt;
+  const durationDays = durationMs / (1000 * 60 * 60 * 24);
+
+  // Round to 2 decimal places
+  return Math.round(durationDays * 100) / 100;
+}
+
+/**
+ * Get evidence impact for outcome
+ *
+ * Task 6: Confidence evolution - Calculate impact based on outcome
+ * AC #5: Confidence score calculated based on history
+ *
+ * @param {string} outcome - Outcome type ('FAILED', 'SUCCESS', 'PARTIAL')
+ * @param {number} durationDays - Duration in days
+ * @returns {number} Impact on confidence
+ */
+function getEvidenceImpact(outcome, durationDays) {
+  // Task 6.3: Define evidence impacts
+  let impact = 0;
+
+  switch (outcome) {
+    case 'SUCCESS':
+      impact = 0.2; // +0.2 for success
+      break;
+    case 'FAILED':
+      impact = -0.3; // -0.3 for failure
+      break;
+    case 'PARTIAL':
+      impact = 0.1; // +0.1 for partial success
+      break;
+  }
+
+  // Task 6.3: Temporal stability bonus (30+ days)
+  if (outcome === 'SUCCESS' && durationDays >= 30) {
+    impact += 0.1; // +0.1 for temporal stability
+  }
+
+  return impact;
+}
+
+/**
+ * Mark decision outcome
+ *
+ * Task 4.8: Update decision row with outcome, failure_reason, duration_days
+ * Task 6.5: Update confidence when outcome is marked
+ * AC #3: Outcome marked with failure_reason and duration_days
+ * AC #5: Confidence evolution
+ *
+ * @param {string} decisionId - Decision ID
+ * @param {string} outcome - Outcome type ('FAILED', 'SUCCESS', 'PARTIAL')
+ * @param {string} failureReason - Failure reason (if outcome=FAILED)
+ * @param {number} durationDays - Duration in days
+ */
+function markOutcome(decisionId, outcome, failureReason, durationDays) {
+  try {
+    // Get current decision to read confidence
+    const db = getDB();
+    const decision = db.prepare('SELECT * FROM decisions WHERE id = ?').get(decisionId);
+
+    if (!decision) {
+      throw new Error(`Decision not found: ${decisionId}`);
+    }
+
+    // Task 6.5: Calculate new confidence
+    const evidenceImpact = getEvidenceImpact(outcome, durationDays);
+    const evidence = [{ type: outcome, impact: evidenceImpact }];
+    const newConfidence = updateConfidence(decision.confidence, evidence);
+
+    // Update decision with outcome and new confidence
+    updateDecisionOutcome(decisionId, {
+      outcome,
+      failure_reason: failureReason,
+      duration_days: durationDays,
+      confidence: newConfidence,
+    });
+
+    info(
+      `[MAMA] Confidence updated: ${decision.confidence.toFixed(2)} → ${newConfidence.toFixed(2)} (${outcome})`
+    );
+  } catch (error) {
+    throw new Error(`Failed to mark outcome: ${error.message}`);
+  }
+}
+
+/**
+ * UserPromptSubmit Handler
+ *
+ * Task 4.4: On UserPromptSubmit, analyze user message for indicators
+ * Task 4.5: If matches + recent decision (< 1 hour), mark outcome
+ * Task 4.6: Extract failure_reason from user message
+ * Task 4.7: Calculate duration_days
+ * Task 4.8: Update decision row
+ *
+ * AC #3: Failure tracking (user feedback → outcome marked)
+ *
+ * @param {Object} hookContext - Hook context from Claude Code
+ * @param {string} hookContext.user_message - User's message
+ * @param {string} hookContext.session_id - Session ID
+ */
+function onUserPromptSubmit(hookContext) {
+  try {
+    const userMessage = hookContext.user_message || '';
+    const sessionId = hookContext.session_id || '';
+
+    // Task 4.4: Analyze user message for outcome
+    const outcome = analyzeOutcome(userMessage);
+
+    if (!outcome) {
+      // No clear outcome detected
+      return;
+    }
+
+    // Task 4.5: Find recent decision (< 1 hour)
+    const recentDecision = getRecentDecision(sessionId);
+
+    if (!recentDecision) {
+      // No recent decision to mark
+      return;
+    }
+
+    // Task 4.6: Extract failure reason
+    const failureReason = extractFailureReason(userMessage, outcome);
+
+    // Task 4.7: Calculate duration
+    const durationDays = calculateDurationDays(recentDecision.created_at);
+
+    // Task 4.8: Mark outcome
+    markOutcome(recentDecision.id, outcome, failureReason, durationDays);
+
+    info(`[MAMA] Outcome marked: ${recentDecision.id} → ${outcome} (${durationDays} days)`);
+  } catch (error) {
+    // Log error but don't crash hook
+    logError(`[MAMA] Outcome tracking failed: ${error.message}`);
+  }
+}
+
+// Export API
+module.exports = {
+  onUserPromptSubmit,
+  analyzeOutcome,
+  extractFailureReason,
+  getRecentDecision,
+  calculateDurationDays,
+  markOutcome,
+  matchesFailureIndicators,
+  matchesSuccessIndicators,
+  matchesPartialIndicators,
+  FAILURE_INDICATORS,
+  SUCCESS_INDICATORS,
+  PARTIAL_INDICATORS,
+  RECENT_WINDOW_MS,
+};

package/src/mama/query-intent.js

@@ -0,0 +1,236 @@
+/**
+ * MAMA (Memory-Augmented MCP Architecture) - Query Intent Analysis
+ *
+ * Analyzes user queries to detect decision-related intent using EXAONE 3.5
+ * Tasks: 2.1-2.8 (LLM intent analysis with fallback chain)
+ * AC #1: Query intent analysis within 100ms
+ * AC #5: LLM fallback (EXAONE → Gemma → Qwen)
+ *
+ * @module query-intent
+ * @version 1.0
+ * @date 2025-11-14
+ */
+
+const { info, error: logError } = require('./debug-logger');
+const { generate, DEFAULT_MODEL, FALLBACK_MODEL } = require('./ollama-client');
+
+/**
+ * Analyze user message for decision-related intent
+ *
+ * Task 2.1-2.5: LLM intent analysis
+ * AC #1: Detect if query involves decisions
+ * AC #5: Fallback chain implemented
+ *
+ * @param {string} userMessage - User's message to analyze
+ * @param {Object} options - Analysis options
+ * @param {number} options.timeout - Timeout in ms (default: 100ms)
+ * @param {number} options.threshold - Minimum confidence (default: 0.6)
+ * @returns {Promise<Object>} Intent analysis result
+ */
+async function analyzeIntent(userMessage, options = {}) {
+  const {
+    timeout = 5000, // Increased: LLM needs time, user accepts longer thinking
+    threshold = 0.6,
+  } = options;
+
+  const startTime = Date.now();
+
+  try {
+    // Task 2.2: Build prompt for decision-making analysis
+    const prompt = `
+Analyze if this query involves decision-making or past choices:
+
+User Message: "${userMessage}"
+
+Decision Indicators:
+1. References to past decisions ("we chose X", "last time we did Y")
+2. Questions about previous approaches ("why did we use X?")
+3. Decision evolution queries ("should we change from X to Y?")
+4. Architecture/strategy questions
+5. Method/approach questions ("how do I...", "what's the way to...")
+6. Best practice questions ("what should I use for...", "which one should I use...")
+
+Return JSON with "topic" as a short snake_case identifier (e.g., "mesh_structure", "database_choice", "auth_strategy", "coding_style", "error_handling"):
+{
+  "involves_decision": boolean,
+  "topic": string or null (extract main technical topic in snake_case),
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation"
+}
+
+IMPORTANT: Generate "topic" freely based on the message content. Do NOT limit to predefined values.
+
+Examples:
+- "Why did we choose COMPLEX mesh structure?" → {"involves_decision": true, "topic": "mesh_structure", "confidence": 0.9}
+- "Let's use PostgreSQL for database" → {"involves_decision": true, "topic": "database_choice", "confidence": 0.9}
+- "How should we store workflow data?" → {"involves_decision": true, "topic": "workflow_storage", "confidence": 0.85}
+- "Read the file please" → {"involves_decision": false, "topic": null, "confidence": 0.1}
+`.trim();
+
+    // Task 2.3: Call EXAONE 3.5 with Tier 1 fallback
+    const result = await generateWithFallback(prompt, {
+      format: 'json',
+      temperature: 0.3,
+      max_tokens: 200,
+      timeout,
+    });
+
+    const latency = Date.now() - startTime;
+
+    // Task 2.4: Parse response
+    const parsed = typeof result === 'string' ? JSON.parse(result) : result;
+
+    // Task 2.5: Threshold check
+    const meetsThreshold = parsed.confidence >= threshold;
+
+    if (!meetsThreshold) {
+      info(`[MAMA] Intent confidence ${parsed.confidence} below threshold ${threshold}`);
+      return {
+        involves_decision: false,
+        topic: null,
+        confidence: parsed.confidence,
+        reasoning: 'Confidence below threshold',
+      };
+    }
+
+    return parsed;
+  } catch (error) {
+    // CLAUDE.md Rule #1: NO FALLBACK
+    // Errors must be thrown for debugging
+    logError(`[MAMA] Intent analysis FAILED: ${error.message}`);
+    throw new Error(`Intent analysis failed: ${error.message}`);
+  }
+}
+
+/**
+ * Generate with tiered fallback chain
+ *
+ * Task 2.6-2.7: Implement fallback to Gemma 2B and Qwen 3B
+ * AC #5: LLM fallback works
+ *
+ * @param {string} prompt - LLM prompt
+ * @param {Object} options - Generation options
+ * @returns {Promise<Object|string>} LLM response
+ */
+async function generateWithFallback(prompt, options = {}) {
+  const models = [
+    DEFAULT_MODEL, // Tier 1: EXAONE 3.5 (2.4B)
+    FALLBACK_MODEL, // Tier 2: Gemma 2B
+    'qwen:3b', // Tier 3: Qwen 3B
+  ];
+
+  for (let i = 0; i < models.length; i++) {
+    const model = models[i];
+
+    try {
+      info(`[MAMA] Trying ${model}...`);
+
+      const result = await generate(prompt, {
+        ...options,
+        model,
+      });
+
+      info(`[MAMA] ${model} succeeded`);
+      return result;
+    } catch (error) {
+      console.warn(`[MAMA] ${model} failed: ${error.message}`);
+
+      // Continue to next tier
+      if (i === models.length - 1) {
+        // All tiers failed
+        throw new Error(`All LLM tiers failed. Last error: ${error.message}`);
+      }
+    }
+  }
+}
+
+/**
+ * Extract topic keywords from user message (fallback method)
+ *
+ * Task 2.8: Keyword-based fallback when all LLMs fail
+ * Simple regex matching for common topics
+ *
+ * @param {string} userMessage - User's message
+ * @returns {Object} Topic detection result
+ */
+function extractTopicKeywords(userMessage) {
+  const topicPatterns = {
+    workflow_storage: /workflow|save|persist/i,
+    mesh_structure: /mesh|structure/i,
+    authentication: /auth|jwt|oauth|login/i,
+    testing: /test|jest|spec/i,
+    architecture: /architecture|design/i,
+    coding_style: /style|format|coding/i,
+  };
+
+  for (const [topic, pattern] of Object.entries(topicPatterns)) {
+    if (pattern.test(userMessage)) {
+      return {
+        involves_decision: true,
+        topic,
+        confidence: 0.5, // Lower confidence for keyword matching
+        reasoning: 'Keyword-based detection (LLM fallback)',
+      };
+    }
+  }
+
+  return {
+    involves_decision: false,
+    topic: null,
+    confidence: 0.0,
+    reasoning: 'No topic keywords found',
+  };
+}
+
+// Export API
+module.exports = {
+  analyzeIntent,
+  extractTopicKeywords,
+};
+
+// CLI execution for testing
+if (require.main === module) {
+  info('🧠 MAMA Query Intent Analysis - Test\n');
+
+  // Task 2.8: Test intent detection accuracy
+  (async () => {
+    const testQueries = [
+      {
+        message: 'Why did we choose COMPLEX mesh structure?',
+        expected: { involves_decision: true, topic: 'mesh_structure' },
+      },
+      {
+        message: 'Read the file please',
+        expected: { involves_decision: false },
+      },
+      {
+        message: 'We chose JWT for authentication, remember?',
+        expected: { involves_decision: true, topic: 'authentication' },
+      },
+    ];
+
+    for (const test of testQueries) {
+      info(`📋 Testing: "${test.message}"`);
+
+      try {
+        const result = await analyzeIntent(test.message);
+        info('✅ Result:', result);
+
+        // Verify expectations
+        if (result.involves_decision === test.expected.involves_decision) {
+          info('   ✓ Decision detection matches');
+        } else {
+          info('   ✗ Decision detection MISMATCH');
+        }
+
+        info('');
+      } catch (error) {
+        logError(`❌ Error: ${error.message}\n`);
+      }
+    }
+
+    info('═══════════════════════════');
+    info('✅ Intent analysis tests complete');
+    info('═══════════════════════════');
+  })();
+}