@jungjaehoon/mama-core 1.1.2 → 1.1.3

package/dist/outcome-tracker.js

@@ -0,0 +1,315 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECENT_WINDOW_MS = exports.PARTIAL_INDICATORS = exports.SUCCESS_INDICATORS = exports.FAILURE_INDICATORS = void 0;
+exports.matchesFailureIndicators = matchesFailureIndicators;
+exports.matchesSuccessIndicators = matchesSuccessIndicators;
+exports.matchesPartialIndicators = matchesPartialIndicators;
+exports.analyzeOutcome = analyzeOutcome;
+exports.extractFailureReason = extractFailureReason;
+exports.getRecentDecision = getRecentDecision;
+exports.calculateDurationDays = calculateDurationDays;
+exports.getEvidenceImpact = getEvidenceImpact;
+exports.markOutcome = markOutcome;
+exports.onUserPromptSubmit = onUserPromptSubmit;
+const debug_logger_js_1 = require("./debug-logger.js");
+const memory_store_js_1 = require("./memory-store.js");
+const decision_tracker_js_1 = require("./decision-tracker.js");
+/**
+ * Failure indicators
+ * Task 4.2: Define failure indicators
+ */
+exports.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
+ */
+exports.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
+ */
+exports.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)
+ */
+exports.RECENT_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+/**
+ * Check if message matches failure indicators
+ *
+ * Task 4.2: Match failure patterns
+ *
+ * @param message - User message
+ * @returns True if failure detected
+ */
+function matchesFailureIndicators(message) {
+    return exports.FAILURE_INDICATORS.some((pattern) => pattern.test(message));
+}
+/**
+ * Check if message matches success indicators
+ *
+ * Task 4.3: Match success patterns
+ *
+ * @param message - User message
+ * @returns True if success detected
+ */
+function matchesSuccessIndicators(message) {
+    return exports.SUCCESS_INDICATORS.some((pattern) => pattern.test(message));
+}
+/**
+ * Check if message matches partial success indicators
+ *
+ * Task 4.3: Match partial success patterns
+ *
+ * @param message - User message
+ * @returns True if partial success detected
+ */
+function matchesPartialIndicators(message) {
+    return exports.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 message - User message
+ * @returns 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 message - User message
+ * @param outcome - Outcome type
+ * @returns 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 sessionId - Session ID
+ * @returns Recent decision or null
+ */
+function getRecentDecision(sessionId) {
+    const db = (0, memory_store_js_1.getDB)();
+    try {
+        const now = Date.now();
+        const cutoffTime = now - exports.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) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to query recent decision: ${message}`);
+    }
+}
+/**
+ * Calculate duration in days
+ *
+ * Task 4.7: Calculate duration_days
+ * AC #3: duration_days calculated
+ *
+ * @param createdAt - Decision created timestamp
+ * @returns 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 outcome - Outcome type ('FAILED', 'SUCCESS', 'PARTIAL')
+ * @param durationDays - Duration in days
+ * @returns 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 decisionId - Decision ID
+ * @param outcome - Outcome type ('FAILED', 'SUCCESS', 'PARTIAL')
+ * @param failureReason - Failure reason (if outcome=FAILED)
+ * @param durationDays - Duration in days
+ */
+async function markOutcome(decisionId, outcome, failureReason, durationDays) {
+    try {
+        // Get current decision to read confidence
+        const db = (0, memory_store_js_1.getDB)();
+        const decision = db.prepare('SELECT * FROM decisions WHERE id = ?').get(decisionId);
+        if (!decision) {
+            throw new Error(`Decision not found: ${decisionId}`);
+        }
+        // Guard against double-marking
+        if (decision.outcome) {
+            (0, debug_logger_js_1.info)(`[MAMA] Outcome already set for ${decisionId}: ${decision.outcome}`);
+            return;
+        }
+        // Task 6.5: Calculate new confidence
+        const evidenceImpact = getEvidenceImpact(outcome, durationDays);
+        // Map OutcomeType to EvidenceItem.type (FAILED → failure, not 'failed')
+        const outcomeToEvidenceType = {
+            SUCCESS: 'success',
+            FAILED: 'failure',
+            PARTIAL: 'partial',
+        };
+        const evidence = [
+            { type: outcomeToEvidenceType[outcome], impact: evidenceImpact },
+        ];
+        const prevConfidence = Number(decision.confidence ?? 0);
+        const newConfidence = (0, decision_tracker_js_1.updateConfidence)(prevConfidence, evidence);
+        // Update decision with outcome and new confidence
+        await (0, memory_store_js_1.updateDecisionOutcome)(decisionId, {
+            outcome,
+            failure_reason: failureReason,
+            duration_days: durationDays,
+            confidence: newConfidence,
+        });
+        (0, debug_logger_js_1.info)(`[MAMA] Confidence updated: ${prevConfidence.toFixed(2)} → ${newConfidence.toFixed(2)} (${outcome})`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to mark outcome: ${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 hookContext - Hook context from Claude Code
+ */
+async 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
+        await markOutcome(recentDecision.id, outcome, failureReason, durationDays);
+        (0, debug_logger_js_1.info)(`[MAMA] Outcome marked: ${recentDecision.id} → ${outcome} (${durationDays} days)`);
+    }
+    catch (error) {
+        // Log error but don't crash hook
+        const message = error instanceof Error ? error.message : String(error);
+        (0, debug_logger_js_1.error)(`[MAMA] Outcome tracking failed: ${message}`);
+    }
+}
+//# sourceMappingURL=outcome-tracker.js.map

package/dist/progress-indicator.d.ts

@@ -0,0 +1,48 @@
+/**
+ * MAMA Progress Indicator
+ *
+ * Text-based progress feedback for long-running operations.
+ * Helps first-time users understand what's happening during initialization.
+ *
+ * Features:
+ * - Logs to stderr (no stdout pollution)
+ * - Emoji indicators: ⏳ (loading), ✅ (done), ❌ (error)
+ * - Concise messages (<50 chars)
+ *
+ * @module progress-indicator
+ */
+/**
+ * Log progress message to stderr
+ *
+ * Format: [MAMA] emoji message
+ * Example: [MAMA] ⏳ Downloading embedding model (120MB)...
+ *
+ * @param message - Progress message (without emoji or prefix)
+ * @param emoji - Emoji indicator (⏳, ✅, ❌, 🔍, etc.)
+ */
+export declare function logProgress(message: string, emoji?: string): void;
+/**
+ * Log completion message
+ */
+export declare function logComplete(message: string): void;
+/**
+ * Log failure/error message (user-facing progress indicator)
+ *
+ * Note: Named logFailed to avoid confusion with debug-logger's logError
+ * which is used for internal debugging. This is for user-facing progress.
+ */
+export declare function logFailed(message: string): void;
+export declare const logError: typeof logFailed;
+/**
+ * Log info message
+ */
+export declare function logInfo(message: string): void;
+/**
+ * Log loading message
+ */
+export declare function logLoading(message: string): void;
+/**
+ * Log searching message
+ */
+export declare function logSearching(message: string): void;
+//# sourceMappingURL=progress-indicator.d.ts.map

package/dist/progress-indicator.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * MAMA Progress Indicator
+ *
+ * Text-based progress feedback for long-running operations.
+ * Helps first-time users understand what's happening during initialization.
+ *
+ * Features:
+ * - Logs to stderr (no stdout pollution)
+ * - Emoji indicators: ⏳ (loading), ✅ (done), ❌ (error)
+ * - Concise messages (<50 chars)
+ *
+ * @module progress-indicator
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logError = void 0;
+exports.logProgress = logProgress;
+exports.logComplete = logComplete;
+exports.logFailed = logFailed;
+exports.logInfo = logInfo;
+exports.logLoading = logLoading;
+exports.logSearching = logSearching;
+/**
+ * Log progress message to stderr
+ *
+ * Format: [MAMA] emoji message
+ * Example: [MAMA] ⏳ Downloading embedding model (120MB)...
+ *
+ * @param message - Progress message (without emoji or prefix)
+ * @param emoji - Emoji indicator (⏳, ✅, ❌, 🔍, etc.)
+ */
+function logProgress(message, emoji = '⏳') {
+    // Ensure message is a string - warn in development if not
+    if (typeof message !== 'string') {
+        if (process.env.NODE_ENV === 'development' || process.env.MAMA_DEBUG) {
+            console.error(`[MAMA] ⚠️ logProgress expected string, got ${typeof message}`);
+        }
+        return;
+    }
+    // Log to stderr to avoid stdout pollution
+    // stderr is used for progress/diagnostic output
+    console.error(`[MAMA] ${emoji} ${message}`);
+}
+/**
+ * Log completion message
+ */
+function logComplete(message) {
+    logProgress(message, '✅');
+}
+/**
+ * Log failure/error message (user-facing progress indicator)
+ *
+ * Note: Named logFailed to avoid confusion with debug-logger's logError
+ * which is used for internal debugging. This is for user-facing progress.
+ */
+function logFailed(message) {
+    logProgress(message, '❌');
+}
+// Alias for backward compatibility
+exports.logError = logFailed;
+/**
+ * Log info message
+ */
+function logInfo(message) {
+    logProgress(message, 'ℹ️');
+}
+/**
+ * Log loading message
+ */
+function logLoading(message) {
+    logProgress(message, '⏳');
+}
+/**
+ * Log searching message
+ */
+function logSearching(message) {
+    logProgress(message, '🔍');
+}
+// Note: Removed auto-registered SIGINT/SIGTERM handlers that called process.exit(0)
+// This was causing issues with host cleanup in parent processes.
+// If graceful shutdown is needed, the host application should handle it.
+//# sourceMappingURL=progress-indicator.js.map

package/dist/query-intent.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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)
+ *
+ * @module query-intent
+ */
+export interface IntentResult {
+    involves_decision: boolean;
+    topic: string | null;
+    confidence: number;
+    reasoning: string;
+}
+export interface AnalyzeOptions {
+    timeout?: number;
+    threshold?: number;
+}
+/**
+ * Analyze user message for decision-related intent
+ */
+export declare function analyzeIntent(userMessage: string, options?: AnalyzeOptions): Promise<IntentResult>;
+/**
+ * Extract topic keywords from user message (fallback method)
+ */
+export declare function extractTopicKeywords(userMessage: string): IntentResult;
+//# sourceMappingURL=query-intent.d.ts.map

package/dist/query-intent.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * 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)
+ *
+ * @module query-intent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeIntent = analyzeIntent;
+exports.extractTopicKeywords = extractTopicKeywords;
+const debug_logger_js_1 = require("./debug-logger.js");
+const ollama_client_js_1 = require("./ollama-client.js");
+/**
+ * Analyze user message for decision-related intent
+ */
+async function analyzeIntent(userMessage, options = {}) {
+    const { timeout = 5000, // Increased: LLM needs time, user accepts longer thinking
+    threshold = 0.6, } = options;
+    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,
+        });
+        // 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) {
+            (0, debug_logger_js_1.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
+        const message = error instanceof Error ? error.message : String(error);
+        (0, debug_logger_js_1.error)(`[MAMA] Intent analysis FAILED: ${message}`);
+        throw new Error(`Intent analysis failed: ${message}`);
+    }
+}
+/**
+ * Generate with tiered fallback chain
+ */
+async function generateWithFallback(prompt, options = {}) {
+    const models = [
+        ollama_client_js_1.DEFAULT_MODEL, // Tier 1: EXAONE 3.5 (2.4B)
+        ollama_client_js_1.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 {
+            (0, debug_logger_js_1.info)(`[MAMA] Trying ${model}...`);
+            const result = await (0, ollama_client_js_1.generate)(prompt, {
+                ...options,
+                model,
+            });
+            (0, debug_logger_js_1.info)(`[MAMA] ${model} succeeded`);
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            (0, debug_logger_js_1.warn)(`[MAMA] ${model} failed: ${message}`);
+            // Continue to next tier
+            if (i === models.length - 1) {
+                // All tiers failed
+                throw new Error(`All LLM tiers failed. Last error: ${message}`);
+            }
+        }
+    }
+    // Unreachable: loop always returns or throws
+    throw new Error('Unexpected: all LLM tiers exhausted without result');
+}
+/**
+ * Extract topic keywords from user message (fallback method)
+ */
+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',
+    };
+}
+//# sourceMappingURL=query-intent.js.map