@jungjaehoon/mama-core 1.1.1 → 1.1.3

package/dist/ollama-client.js

@@ -0,0 +1,308 @@
+"use strict";
+/**
+ * MAMA (Memory-Augmented MCP Architecture) - Ollama Client Wrapper
+ *
+ * Simple wrapper for Ollama API with EXAONE 3.5 support
+ *
+ * @module ollama-client
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FALLBACK_MODEL = exports.DEFAULT_MODEL = void 0;
+exports.generate = generate;
+exports.analyzeDecision = analyzeDecision;
+exports.analyzeQueryIntent = analyzeQueryIntent;
+exports.isAvailable = isAvailable;
+exports.listModels = listModels;
+const http_1 = __importDefault(require("http"));
+const debug_logger_js_1 = require("./debug-logger.js");
+// Ollama configuration
+const OLLAMA_HOST = process.env.OLLAMA_HOST || 'localhost';
+const OLLAMA_PORT = parseInt(process.env.OLLAMA_PORT || '11434', 10);
+exports.DEFAULT_MODEL = 'exaone3.5:2.4b';
+exports.FALLBACK_MODEL = 'gemma:2b';
+/**
+ * Call Ollama API
+ */
+function callOllamaAPI(endpoint, payload, timeout = 30000) {
+    return new Promise((resolve, reject) => {
+        const postData = JSON.stringify(payload);
+        const options = {
+            hostname: OLLAMA_HOST,
+            port: OLLAMA_PORT,
+            path: endpoint,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(postData),
+            },
+        };
+        const req = http_1.default.request(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    try {
+                        // Ollama returns NDJSON (newline-delimited JSON)
+                        const lines = data.trim().split('\n');
+                        const response = JSON.parse(lines[lines.length - 1]);
+                        resolve(response);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        reject(new Error(`Failed to parse Ollama response: ${message}`));
+                    }
+                }
+                else {
+                    reject(new Error(`Ollama API error: ${res.statusCode} - ${data}`));
+                }
+            });
+        });
+        req.on('error', (error) => {
+            reject(new Error(`Ollama connection failed: ${error.message}`));
+        });
+        req.setTimeout(timeout, () => {
+            req.destroy();
+            reject(new Error(`Ollama request timeout (${timeout}ms)`));
+        });
+        req.write(postData);
+        req.end();
+    });
+}
+/**
+ * Generate text with EXAONE 3.5
+ */
+async function generate(prompt, options = {}) {
+    const { model = exports.DEFAULT_MODEL, format = null, temperature = 0.7, max_tokens = 500, timeout = 30000, } = options;
+    const payload = {
+        model,
+        prompt,
+        stream: false,
+        options: {
+            temperature,
+            num_predict: max_tokens,
+        },
+    };
+    if (format === 'json') {
+        payload.format = 'json';
+    }
+    try {
+        const response = await callOllamaAPI('/api/generate', payload, timeout);
+        // Extract response text
+        const responseText = response.response;
+        // Parse JSON if requested
+        if (format === 'json') {
+            try {
+                return JSON.parse(responseText);
+            }
+            catch {
+                throw new Error(`Failed to parse JSON response: ${responseText}`);
+            }
+        }
+        return responseText;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // Try fallback model if EXAONE fails
+        const isModelNotFound = /model ['"].*['"] not found/i.test(message) ||
+            (message.includes('404') && message.toLowerCase().includes('not found'));
+        if (model === exports.DEFAULT_MODEL && isModelNotFound) {
+            (0, debug_logger_js_1.error)(`[MAMA] EXAONE not found, trying fallback (${exports.FALLBACK_MODEL})...`);
+            return generate(prompt, {
+                ...options,
+                model: exports.FALLBACK_MODEL,
+            });
+        }
+        throw error;
+    }
+}
+/**
+ * Validate DecisionAnalysisResult shape at runtime
+ */
+function isDecisionAnalysisResult(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const o = obj;
+    return (typeof o.is_decision === 'boolean' &&
+        (typeof o.topic === 'string' || o.topic === null) &&
+        (typeof o.decision === 'string' || o.decision === null) &&
+        typeof o.reasoning === 'string' &&
+        typeof o.confidence === 'number');
+}
+/**
+ * Validate QueryIntentResult shape at runtime
+ */
+function isQueryIntentResult(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const o = obj;
+    return (typeof o.involves_decision === 'boolean' &&
+        (typeof o.topic === 'string' || o.topic === null) &&
+        (o.query_type === 'recall' || o.query_type === 'evolution' || o.query_type === 'none') &&
+        typeof o.reasoning === 'string');
+}
+/**
+ * Analyze decision from tool execution
+ */
+async function analyzeDecision(toolExecution, sessionContext) {
+    const prompt = `
+Analyze if this represents a DECISION (not just an action):
+
+Session Context:
+- Latest User Message: ${sessionContext.latest_user_message || 'N/A'}
+- Recent Exchange: ${sessionContext.recent_exchange || 'N/A'}
+
+Tool Execution:
+- Tool: ${toolExecution.tool_name ?? 'N/A'}
+- Input: ${JSON.stringify(toolExecution.tool_input ?? null)}
+- Result: ${toolExecution.exit_code !== undefined ? (toolExecution.exit_code === 0 ? 'SUCCESS' : 'FAILED') : 'UNKNOWN'}
+
+Decision Indicators:
+1. User explicitly chose between alternatives?
+   Example: "Let's use JWT" (not "Use JWT" - that's just action)
+
+2. User changed previous approach?
+   Example: "Complex → Simple approach"
+
+3. User expressed preference?
+   Example: "Let's do it this way from now", "This approach is better"
+
+4. Significant architectural choice?
+   Example: "Mesh structure: COMPLEX", "Authentication: JWT"
+
+Is this a DECISION? Return JSON with "topic" as a short snake_case identifier:
+{
+  "is_decision": boolean,
+  "topic": string or null (extract main technical topic in snake_case, e.g., "mesh_structure", "database_choice", "auth_strategy"),
+  "decision": string or null (the actual choice made, e.g., "COMPLEX", "PostgreSQL", "JWT"),
+  "reasoning": "Why this is/isn't a decision",
+  "confidence": 0.0-1.0
+}
+
+IMPORTANT: Generate "topic" freely based on context. Do NOT limit to predefined values.
+`;
+    try {
+        const response = await generate(prompt, {
+            format: 'json',
+            temperature: 0.3,
+            max_tokens: 300,
+        });
+        if (!isDecisionAnalysisResult(response)) {
+            throw new Error('Invalid LLM response shape for DecisionAnalysisResult');
+        }
+        return response;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, debug_logger_js_1.error)(`[MAMA] Decision analysis FAILED: ${message}`);
+        throw new Error(`Decision analysis failed: ${message}`);
+    }
+}
+/**
+ * Analyze query intent
+ */
+async function analyzeQueryIntent(userMessage) {
+    const prompt = `
+Analyze this user message to determine if it involves past decisions:
+
+User Message: "${userMessage}"
+
+Questions to answer:
+1. Does this query reference past decisions or choices?
+2. Is the user asking about previous approaches?
+3. What topic is being discussed? (e.g., "mesh_structure", "authentication", "testing")
+
+Return JSON:
+{
+  "involves_decision": boolean,
+  "topic": "topic_name" | null,
+  "query_type": "recall" | "evolution" | "none",
+  "reasoning": "Why this involves/doesn't involve decisions"
+}
+`;
+    try {
+        const response = await generate(prompt, {
+            format: 'json',
+            temperature: 0.3,
+            max_tokens: 200,
+        });
+        if (!isQueryIntentResult(response)) {
+            throw new Error('Invalid LLM response shape for QueryIntentResult');
+        }
+        return response;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, debug_logger_js_1.error)(`[MAMA] Query intent analysis FAILED: ${message}`);
+        throw new Error(`Query intent analysis failed: ${message}`);
+    }
+}
+/**
+ * Check if Ollama is available
+ */
+async function isAvailable() {
+    return new Promise((resolve) => {
+        const options = {
+            hostname: OLLAMA_HOST,
+            port: OLLAMA_PORT,
+            path: '/api/tags',
+            method: 'GET',
+            timeout: 2000,
+        };
+        const req = http_1.default.request(options, (res) => {
+            res.resume(); // Drain response body to release socket back to pool
+            resolve(res.statusCode !== undefined && res.statusCode >= 200 && res.statusCode < 300);
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+        req.end();
+    });
+}
+/**
+ * List available models
+ */
+async function listModels() {
+    return new Promise((resolve, reject) => {
+        const options = {
+            hostname: OLLAMA_HOST,
+            port: OLLAMA_PORT,
+            path: '/api/tags',
+            method: 'GET',
+            timeout: 5000,
+        };
+        const req = http_1.default.request(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const response = JSON.parse(data);
+                    resolve(response.models?.map((m) => m.name) || []);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    reject(new Error(`Failed to parse models response: ${message}`));
+                }
+            });
+        });
+        req.on('error', (error) => {
+            reject(new Error(`Failed to list models: ${error.message}`));
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('List models timeout'));
+        });
+        req.end();
+    });
+}
+//# sourceMappingURL=ollama-client.js.map

package/dist/outcome-tracker.d.ts

@@ -0,0 +1,165 @@
+/**
+ * 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
+ */
+/**
+ * Decision record from database
+ */
+interface DecisionRecord {
+    id: string;
+    topic: string;
+    decision: string;
+    outcome?: string | null;
+    confidence?: number;
+    created_at: number;
+}
+/**
+ * Hook context from Claude Code
+ */
+export interface HookContext {
+    user_message?: string;
+    session_id?: string;
+}
+/**
+ * Failure indicators
+ * Task 4.2: Define failure indicators
+ */
+export declare const FAILURE_INDICATORS: RegExp[];
+/**
+ * Success indicators
+ * Task 4.3: Define success indicators
+ */
+export declare const SUCCESS_INDICATORS: RegExp[];
+/**
+ * Partial success indicators
+ * Task 4.3: Define partial success indicators
+ */
+export declare const PARTIAL_INDICATORS: RegExp[];
+/**
+ * Recent decision time window (1 hour in milliseconds)
+ * Task 4.5: Only mark outcome if decision is recent (< 1 hour)
+ */
+export declare const RECENT_WINDOW_MS: number;
+/**
+ * Check if message matches failure indicators
+ *
+ * Task 4.2: Match failure patterns
+ *
+ * @param message - User message
+ * @returns True if failure detected
+ */
+export declare function matchesFailureIndicators(message: string): boolean;
+/**
+ * Check if message matches success indicators
+ *
+ * Task 4.3: Match success patterns
+ *
+ * @param message - User message
+ * @returns True if success detected
+ */
+export declare function matchesSuccessIndicators(message: string): boolean;
+/**
+ * Check if message matches partial success indicators
+ *
+ * Task 4.3: Match partial success patterns
+ *
+ * @param message - User message
+ * @returns True if partial success detected
+ */
+export declare function matchesPartialIndicators(message: string): boolean;
+/**
+ * Outcome type from analysis
+ */
+export type OutcomeType = 'FAILED' | 'SUCCESS' | 'PARTIAL';
+/**
+ * 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
+ */
+export declare function analyzeOutcome(message: string): OutcomeType | null;
+/**
+ * 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
+ */
+export declare function extractFailureReason(message: string, outcome: OutcomeType | null): string | null;
+/**
+ * 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
+ */
+export declare function getRecentDecision(sessionId: string): DecisionRecord | null;
+/**
+ * Calculate duration in days
+ *
+ * Task 4.7: Calculate duration_days
+ * AC #3: duration_days calculated
+ *
+ * @param createdAt - Decision created timestamp
+ * @returns Duration in days
+ */
+export declare function calculateDurationDays(createdAt: number): number;
+/**
+ * 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
+ */
+export declare function getEvidenceImpact(outcome: OutcomeType, durationDays: number): number;
+/**
+ * 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
+ */
+export declare function markOutcome(decisionId: string, outcome: OutcomeType, failureReason: string | null, durationDays: number): Promise<void>;
+/**
+ * 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
+ */
+export declare function onUserPromptSubmit(hookContext: HookContext): Promise<void>;
+export {};
+//# sourceMappingURL=outcome-tracker.d.ts.map