@jungjaehoon/mama-core 1.1.1 → 1.1.3

package/dist/memory-inject.d.ts

@@ -0,0 +1,24 @@
+/**
+ * MAMA (Memory-Augmented MCP Architecture) - Memory Injection Hook
+ *
+ * UserPromptSubmit hook that injects decision history into Claude's context
+ * Tasks: 1.1-1.9 (Hook setup, timeout handling, context injection)
+ * AC #1: Query intent → Graph query → Format → Inject (5s timeout for LLM latency)
+ * AC #2: No history → null (graceful fallback)
+ * AC #3: Timeout → graceful fallback
+ *
+ * @module memory-inject
+ * @version 1.0
+ * @date 2025-11-14
+ */
+/**
+ * UserPromptSubmit Hook Handler
+ *
+ * Task 1.1-1.9: Main entry point for memory injection
+ * AC #1, #2, #3: Intent analysis → Query → Format → Inject
+ *
+ * @param userMessage - User's message from prompt
+ * @returns Injected context or null
+ */
+export declare function injectDecisionContext(userMessage: string): Promise<string | null>;
+//# sourceMappingURL=memory-inject.d.ts.map

package/dist/memory-inject.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * MAMA (Memory-Augmented MCP Architecture) - Memory Injection Hook
+ *
+ * UserPromptSubmit hook that injects decision history into Claude's context
+ * Tasks: 1.1-1.9 (Hook setup, timeout handling, context injection)
+ * AC #1: Query intent → Graph query → Format → Inject (5s timeout for LLM latency)
+ * AC #2: No history → null (graceful fallback)
+ * AC #3: Timeout → graceful fallback
+ *
+ * @module memory-inject
+ * @version 1.0
+ * @date 2025-11-14
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectDecisionContext = injectDecisionContext;
+// Error handling policy:
+// - Timeout errors: thrown (caller handles retry/fallback)
+// - Vector search unavailable: returns empty array (recoverable, not critical)
+const debug_logger_js_1 = require("./debug-logger.js");
+const memory_store_js_1 = require("./memory-store.js");
+const decision_formatter_js_1 = require("./decision-formatter.js");
+// Configuration
+const TIMEOUT_MS = 5000; // LLM-based intent detection, user accepts longer thinking
+const TOKEN_BUDGET = 500; // AC #1: Max 500 tokens per injection
+/**
+ * UserPromptSubmit Hook Handler
+ *
+ * Task 1.1-1.9: Main entry point for memory injection
+ * AC #1, #2, #3: Intent analysis → Query → Format → Inject
+ *
+ * @param userMessage - User's message from prompt
+ * @returns Injected context or null
+ */
+async function injectDecisionContext(userMessage) {
+    const startTime = Date.now();
+    let timeoutId = null;
+    try {
+        // Task 1.3: Implement timeout wrapper (Promise.race with timeout)
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new Error(`Memory injection timeout (${TIMEOUT_MS}ms)`));
+            }, TIMEOUT_MS);
+        });
+        const context = await Promise.race([
+            performMemoryInjection(userMessage, startTime),
+            timeoutPromise,
+        ]);
+        // Clear timeout on success to prevent timer leak
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        return context;
+    }
+    catch (error) {
+        // Clear timeout on error to prevent timer leak
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        // CLAUDE.md Rule #1: NO FALLBACK
+        // Errors must be thrown for debugging (including timeout)
+        const message = error instanceof Error ? error.message : String(error);
+        (0, debug_logger_js_1.error)(`[MAMA] Memory injection FAILED: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Perform memory injection with all steps
+ *
+ * Simplified: Direct vector search without LLM intent analysis
+ * Faster, more reliable, works with all query types
+ *
+ * @param userMessage - User's message
+ * @param startTime - Start timestamp for latency tracking
+ * @returns Formatted context or null
+ */
+async function performMemoryInjection(userMessage, startTime) {
+    // 1. Generate query embedding
+    const { generateEmbedding } = await import('./embeddings.js');
+    const queryEmbedding = await generateEmbedding(userMessage);
+    const embeddingLatency = Date.now() - startTime;
+    (0, debug_logger_js_1.info)(`[MAMA] Embedding generation: ${embeddingLatency}ms`);
+    // 2. Adaptive threshold (shorter queries need higher confidence)
+    const wordCount = userMessage.split(/\s+/).length;
+    const adaptiveThreshold = wordCount < 3 ? 0.7 : 0.6;
+    // 3. Vector search (returns [] on error for graceful degradation)
+    let results;
+    try {
+        results = (await (0, memory_store_js_1.vectorSearch)(queryEmbedding, 10, 0.5)); // Get more candidates
+    }
+    catch (error) {
+        // Vector search unavailability should not block the main conversation flow
+        const message = error instanceof Error ? error.message : String(error);
+        (0, debug_logger_js_1.error)(`[MAMA] Vector search failed: ${message}`);
+        return null;
+    }
+    // 4. Filter by adaptive threshold
+    results = results.filter((r) => r.similarity >= adaptiveThreshold);
+    const searchLatency = Date.now() - startTime;
+    (0, debug_logger_js_1.info)(`[MAMA] Vector search: ${searchLatency - embeddingLatency}ms (${results.length} results, threshold: ${adaptiveThreshold})`);
+    // 5. Check if we have any decisions
+    if (results.length === 0) {
+        // Redact user content for privacy - only log length, not content
+        (0, debug_logger_js_1.info)(`[MAMA] No relevant decisions found (query length: ${userMessage.length} chars)`);
+        return null;
+    }
+    // 6. Format context summary
+    const formattedContext = (0, decision_formatter_js_1.formatContext)(results, {
+        maxTokens: TOKEN_BUDGET,
+    });
+    const formatLatency = Date.now() - startTime;
+    (0, debug_logger_js_1.info)(`[MAMA] Format context: ${formatLatency - searchLatency}ms (total: ${formatLatency}ms)`);
+    // 7. Return formatted context (Claude Code will inject it)
+    return formattedContext;
+}
+//# sourceMappingURL=memory-inject.js.map

package/dist/memory-store.d.ts

@@ -0,0 +1,103 @@
+/**
+ * MAMA Memory Store - Compatibility Wrapper
+ *
+ * This file now serves as a compatibility layer that re-exports db-manager functions.
+ * The actual database logic has been moved to db-manager.js which supports both
+ * SQLite (local development) and PostgreSQL (Railway production).
+ *
+ * Migration Note:
+ * - Old: memory-store.js directly used better-sqlite3 + sqlite-vss
+ * - New: memory-store.js → db-manager.js → db-adapter (SQLite or PostgreSQL)
+ *
+ * All MAMA modules can continue to require('memory-store') without changes.
+ *
+ * @module memory-store
+ * @version 2.0
+ * @date 2025-11-17
+ */
+import * as dbManager from './db-manager.js';
+import type { PreparedStatement, VectorSearchResult } from './db-manager.js';
+export type { PreparedStatement };
+export interface DatabaseAdapter {
+    prepare: (sql: string) => PreparedStatement;
+    vectorSearchEnabled?: boolean;
+    insertEmbedding?: (rowid: number, embedding: Float32Array | number[]) => void;
+    vectorSearch?: (embedding: Float32Array | number[], limit: number) => Promise<VectorSearchResult[] | null>;
+    transaction?: <T>(fn: () => T) => T;
+}
+export interface DecisionForStorage {
+    id: string;
+    topic: string;
+    decision: string;
+    reasoning?: string | null;
+    outcome?: string | null;
+    failure_reason?: string | null;
+    limitation?: string | null;
+    user_involvement?: string | null;
+    session_id?: string | null;
+    supersedes?: string | null;
+    superseded_by?: string | null;
+    refined_from?: string[] | null;
+    confidence?: number;
+    created_at?: number;
+    updated_at?: number;
+    needs_validation?: number;
+    validation_attempts?: number;
+    last_validated_at?: number | null;
+    usage_count?: number;
+    trust_context?: string | null;
+    usage_success?: number;
+    usage_failure?: number;
+    time_saved?: number;
+    evidence?: string | null;
+    alternatives?: string | null;
+    risks?: string | null;
+}
+export interface OutcomeData {
+    outcome?: string | null;
+    failure_reason?: string | null;
+    limitation?: string | null;
+    duration_days?: number | null;
+    confidence?: number | null;
+}
+export interface VectorSearchParams {
+    query: string;
+    limit?: number;
+    threshold?: number;
+    timeWindow?: number;
+}
+export declare const initDB: typeof dbManager.initDB;
+export declare const getDB: typeof dbManager.getDB;
+export declare const getAdapter: typeof dbManager.getAdapter;
+export declare const closeDB: typeof dbManager.closeDB;
+export declare const insertEmbedding: typeof dbManager.insertEmbedding;
+export declare const vectorSearch: typeof dbManager.vectorSearch;
+export declare const queryVectorSearch: typeof dbManager.queryVectorSearch;
+export declare const insertDecisionWithEmbedding: typeof dbManager.insertDecisionWithEmbedding;
+export declare const queryDecisionGraph: typeof dbManager.queryDecisionGraph;
+export declare const querySemanticEdges: typeof dbManager.querySemanticEdges;
+export declare const updateDecisionOutcome: typeof dbManager.updateDecisionOutcome;
+export declare const getPreparedStmt: typeof dbManager.getPreparedStmt;
+export declare const getDbPath: typeof dbManager.getDbPath;
+export declare const traverseDecisionChain: typeof dbManager.queryDecisionGraph;
+/**
+ * Get decisions for a specific session
+ */
+export declare function getSessionDecisions(sessionId: string): Promise<unknown[]>;
+/**
+ * Increment usage success counter
+ */
+export declare function incrementUsageSuccess(decisionId: string, timeSaved?: number): Promise<void>;
+/**
+ * Increment usage failure counter
+ */
+export declare function incrementUsageFailure(decisionId: string): Promise<void>;
+/**
+ * Get decision by ID
+ */
+export declare function getDecisionById(decisionId: string): Promise<unknown>;
+export declare const DB_PATH: string;
+export declare const DB_DIR: string;
+export declare const LEGACY_DB_PATH = "~/.spinelift/memories.db";
+export declare const DEFAULT_DB_PATH = "~/.mama/memories.db";
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/memory-store.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * MAMA Memory Store - Compatibility Wrapper
+ *
+ * This file now serves as a compatibility layer that re-exports db-manager functions.
+ * The actual database logic has been moved to db-manager.js which supports both
+ * SQLite (local development) and PostgreSQL (Railway production).
+ *
+ * Migration Note:
+ * - Old: memory-store.js directly used better-sqlite3 + sqlite-vss
+ * - New: memory-store.js → db-manager.js → db-adapter (SQLite or PostgreSQL)
+ *
+ * All MAMA modules can continue to require('memory-store') without changes.
+ *
+ * @module memory-store
+ * @version 2.0
+ * @date 2025-11-17
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DB_PATH = exports.LEGACY_DB_PATH = exports.DB_DIR = exports.DB_PATH = exports.traverseDecisionChain = exports.getDbPath = exports.getPreparedStmt = exports.updateDecisionOutcome = exports.querySemanticEdges = exports.queryDecisionGraph = exports.insertDecisionWithEmbedding = exports.queryVectorSearch = exports.vectorSearch = exports.insertEmbedding = exports.closeDB = exports.getAdapter = exports.getDB = exports.initDB = void 0;
+exports.getSessionDecisions = getSessionDecisions;
+exports.incrementUsageSuccess = incrementUsageSuccess;
+exports.incrementUsageFailure = incrementUsageFailure;
+exports.getDecisionById = getDecisionById;
+const dbManager = __importStar(require("./db-manager.js"));
+// Re-export all db-manager functions for backward compatibility
+// These maintain the same interface as the original memory-store.js
+exports.initDB = dbManager.initDB;
+exports.getDB = dbManager.getDB;
+exports.getAdapter = dbManager.getAdapter;
+exports.closeDB = dbManager.closeDB;
+exports.insertEmbedding = dbManager.insertEmbedding;
+exports.vectorSearch = dbManager.vectorSearch;
+exports.queryVectorSearch = dbManager.queryVectorSearch;
+exports.insertDecisionWithEmbedding = dbManager.insertDecisionWithEmbedding;
+exports.queryDecisionGraph = dbManager.queryDecisionGraph;
+exports.querySemanticEdges = dbManager.querySemanticEdges;
+exports.updateDecisionOutcome = dbManager.updateDecisionOutcome;
+exports.getPreparedStmt = dbManager.getPreparedStmt;
+exports.getDbPath = dbManager.getDbPath;
+// Legacy exports (for backward compatibility with old code)
+exports.traverseDecisionChain = dbManager.queryDecisionGraph; // Alias
+/**
+ * Get decisions for a specific session
+ */
+async function getSessionDecisions(sessionId) {
+    const adapter = dbManager.getAdapter();
+    const stmt = adapter.prepare(`
+    SELECT * FROM decisions
+    WHERE session_id = ?
+    ORDER BY created_at DESC
+  `);
+    return stmt.all(sessionId);
+}
+/**
+ * Increment usage success counter
+ */
+async function incrementUsageSuccess(decisionId, timeSaved = 0) {
+    const adapter = dbManager.getAdapter();
+    const stmt = adapter.prepare(`
+    UPDATE decisions
+    SET usage_success = usage_success + 1,
+        time_saved = time_saved + ?,
+        updated_at = ?
+    WHERE id = ?
+  `);
+    stmt.run(timeSaved, Date.now(), decisionId);
+}
+/**
+ * Increment usage failure counter
+ */
+async function incrementUsageFailure(decisionId) {
+    const adapter = dbManager.getAdapter();
+    const stmt = adapter.prepare(`
+    UPDATE decisions
+    SET usage_failure = usage_failure + 1,
+        updated_at = ?
+    WHERE id = ?
+  `);
+    stmt.run(Date.now(), decisionId);
+}
+/**
+ * Get decision by ID
+ */
+async function getDecisionById(decisionId) {
+    const adapter = dbManager.getAdapter();
+    const stmt = adapter.prepare('SELECT * FROM decisions WHERE id = ?');
+    return stmt.get(decisionId);
+}
+// Path exports (labels for display/logging, not actual filesystem paths)
+// Note: Actual paths are managed by sqlite-adapter.ts (~/.claude/mama-memory.db)
+exports.DB_PATH = process.env.MAMA_DATABASE_URL ? 'PostgreSQL' : 'SQLite';
+exports.DB_DIR = process.env.MAMA_DATABASE_URL ? 'PostgreSQL' : '~/.mama';
+exports.LEGACY_DB_PATH = '~/.spinelift/memories.db';
+exports.DEFAULT_DB_PATH = '~/.mama/memories.db';
+//# sourceMappingURL=memory-store.js.map

package/dist/notification-manager.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MAMA Notification Manager - Stub module
+ *
+ * @module notification-manager
+ */
+export declare function notifyInsight(): null;
+//# sourceMappingURL=notification-manager.d.ts.map

package/dist/notification-manager.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * MAMA Notification Manager - Stub module
+ *
+ * @module notification-manager
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyInsight = notifyInsight;
+function notifyInsight() {
+    return null;
+}
+//# sourceMappingURL=notification-manager.js.map

package/dist/ollama-client.d.ts

@@ -0,0 +1,51 @@
+/**
+ * MAMA (Memory-Augmented MCP Architecture) - Ollama Client Wrapper
+ *
+ * Simple wrapper for Ollama API with EXAONE 3.5 support
+ *
+ * @module ollama-client
+ */
+import type { ToolExecution, SessionContext } from './decision-tracker.js';
+export declare const DEFAULT_MODEL = "exaone3.5:2.4b";
+export declare const FALLBACK_MODEL = "gemma:2b";
+export interface GenerateOptions {
+    model?: string;
+    format?: string | null;
+    temperature?: number;
+    max_tokens?: number;
+    timeout?: number;
+}
+/**
+ * Generate text with EXAONE 3.5
+ */
+export declare function generate(prompt: string, options?: GenerateOptions): Promise<unknown>;
+export interface DecisionAnalysisResult {
+    is_decision: boolean;
+    topic: string | null;
+    decision: string | null;
+    reasoning: string;
+    confidence: number;
+}
+/**
+ * Analyze decision from tool execution
+ */
+export declare function analyzeDecision(toolExecution: ToolExecution, sessionContext: SessionContext): Promise<DecisionAnalysisResult>;
+export interface QueryIntentResult {
+    involves_decision: boolean;
+    topic: string | null;
+    query_type: 'recall' | 'evolution' | 'none';
+    reasoning: string;
+}
+/**
+ * Analyze query intent
+ */
+export declare function analyzeQueryIntent(userMessage: string): Promise<QueryIntentResult>;
+/**
+ * Check if Ollama is available
+ */
+export declare function isAvailable(): Promise<boolean>;
+/**
+ * List available models
+ */
+export declare function listModels(): Promise<string[]>;
+//# sourceMappingURL=ollama-client.d.ts.map