@jungjaehoon/mama-core 1.1.3 → 1.1.5

package/dist/db-manager.d.ts

@@ -53,7 +53,7 @@ export interface DecisionRecord {
     refined_from?: string | string[] | null;
     created_at: number;
     updated_at?: number;
-    edges?: unknown[];
+    edges?: DecisionEdgeRow[];
 }
 export interface OutcomeData {
     outcome?: string | null;
@@ -68,17 +68,40 @@ export interface VectorSearchParams {
     threshold?: number;
     timeWindow?: number;
 }
+export interface DecisionEdgeRow {
+    from_id: string;
+    to_id: string;
+    relationship: string;
+    reason?: string | null;
+    weight?: number;
+    created_at?: number;
+    created_by?: string;
+    approved_by_user?: number | null;
+    decision_id?: string | null;
+    evidence?: string | null;
+}
+export interface SemanticEdgeItem {
+    from_id: string;
+    to_id: string;
+    relationship: string;
+    reason?: string;
+    topic: string;
+    decision: string;
+    confidence?: number;
+    created_at?: string;
+    approved_by_user?: number | null;
+}
 export interface SemanticEdges {
-    refines: unknown[];
-    refined_by: unknown[];
-    contradicts: unknown[];
-    contradicted_by: unknown[];
-    builds_on: unknown[];
-    built_on_by: unknown[];
-    debates: unknown[];
-    debated_by: unknown[];
-    synthesizes: unknown[];
-    synthesized_by: unknown[];
+    refines: SemanticEdgeItem[];
+    refined_by: SemanticEdgeItem[];
+    contradicts: SemanticEdgeItem[];
+    contradicted_by: SemanticEdgeItem[];
+    builds_on: SemanticEdgeItem[];
+    built_on_by: SemanticEdgeItem[];
+    debates: SemanticEdgeItem[];
+    debated_by: SemanticEdgeItem[];
+    synthesizes: SemanticEdgeItem[];
+    synthesized_by: SemanticEdgeItem[];
 }
 /**
  * Initialize SQLite database adapter and connect

package/dist/embedding-server/mobile/websocket-handler.d.ts

@@ -20,8 +20,18 @@ import type { Server as HTTPServer } from 'http';
 /**
  * Message router interface
  */
+interface StreamCallbacks {
+    onDelta?: (text: string) => void;
+    onToolUse?: (toolName: string, input: Record<string, unknown>) => void;
+    onToolComplete?: (toolName: string, toolUseId: string, isError: boolean) => void;
+    onFinal?: (response: unknown) => void;
+    onError?: (error: Error) => void;
+}
 interface MessageRouter {
-    process(message: NormalizedMessage): Promise<RouterResult>;
+    process(message: NormalizedMessage, options?: {
+        onQueued?: () => void;
+        onStream?: StreamCallbacks;
+    }): Promise<RouterResult>;
 }
 /**
  * Session store interface

package/dist/embedding-server/mobile/websocket-handler.js

@@ -81,6 +81,22 @@ function extractUserId(req) {
         return `user_${Date.now()}`;
     }
 }
+/**
+ * Safe send helper - guards against closed socket with try-catch for race conditions
+ */
+function safeSend(ws, data) {
+    if (ws.readyState === ws_1.WebSocket.OPEN) {
+        try {
+            ws.send(data);
+            return true;
+        }
+        catch {
+            // Socket may have closed between readyState check and send
+            return false;
+        }
+    }
+    return false;
+}
 /**
  * Create WebSocket handler with MessageRouter integration
  */
@@ -202,6 +218,8 @@ async function handleClientMessage(clientId, message, clientInfo, messageRouter,
                     }
                 }, 10000); // Every 10 seconds
                 let result;
+                let deltasSent = false;
+                let toolIndex = 0;
                 try {
                     // Build contentBlocks from attachments (files are pre-compressed by upload-handler)
                     let contentBlocks = undefined;
@@ -269,19 +287,52 @@ async function handleClientMessage(clientId, message, clientInfo, messageRouter,
                             timestamp: Date.now(),
                         },
                     };
-                    result = await messageRouter.process(normalizedMessage);
+                    result = await messageRouter.process(normalizedMessage, {
+                        onQueued: () => {
+                            // Guard: check if socket is still open before sending
+                            if (clientInfo.ws.readyState !== ws_1.WebSocket.OPEN) {
+                                return;
+                            }
+                            // Notify client that message is queued (session busy)
+                            try {
+                                clientInfo.ws.send(JSON.stringify({
+                                    type: 'queued',
+                                    message: '⏳ 이전 요청 처리 중... 대기열에 추가되었습니다.',
+                                }));
+                            }
+                            catch (err) {
+                                logger.warn('Queued notification failed:', err instanceof Error ? err.message : String(err));
+                            }
+                            logger.info(`Message queued for ${clientId} (session busy)`);
+                        },
+                        onStream: {
+                            onDelta: (text) => {
+                                deltasSent = true;
+                                safeSend(clientInfo.ws, JSON.stringify({ type: 'stream', content: text }));
+                            },
+                            onToolUse: (tool, input) => {
+                                const idx = toolIndex++;
+                                safeSend(clientInfo.ws, JSON.stringify({ type: 'tool_use', tool, index: idx, input }));
+                            },
+                            onToolComplete: (tool, _toolUseId, isError) => {
+                                safeSend(clientInfo.ws, JSON.stringify({ type: 'tool_complete', tool, index: toolIndex - 1, isError }));
+                            },
+                        },
+                    });
                 }
                 finally {
                     clearInterval(keepAliveInterval);
                 }
-                // Send response as stream (for Chat tab compatibility)
-                clientInfo.ws.send(JSON.stringify({
-                    type: 'stream',
-                    content: result.response,
-                    sessionId: result.sessionId,
-                }));
-                // Send stream end
-                clientInfo.ws.send(JSON.stringify({
+                // Only send full response if no deltas were streamed (Codex fallback)
+                if (!deltasSent) {
+                    safeSend(clientInfo.ws, JSON.stringify({
+                        type: 'stream',
+                        content: result.response,
+                        sessionId: result.sessionId,
+                    }));
+                }
+                // Always send stream end
+                safeSend(clientInfo.ws, JSON.stringify({
                     type: 'stream_end',
                     sessionId: result.sessionId,
                     duration: result.duration,
@@ -291,7 +342,7 @@ async function handleClientMessage(clientId, message, clientInfo, messageRouter,
             catch (error) {
                 const errMsg = error instanceof Error ? error.message : String(error);
                 logger.error(`Message processing error for ${clientId}:`, errMsg);
-                clientInfo.ws.send(JSON.stringify({
+                safeSend(clientInfo.ws, JSON.stringify({
                     type: 'error',
                     error: 'Failed to process message',
                     // Don't expose internal error details to client for security

package/dist/index.d.ts

@@ -10,7 +10,7 @@
 export { generateEmbedding, generateEnhancedEmbedding, generateBatchEmbeddings, cosineSimilarity, embeddingCache, EMBEDDING_DIM, MODEL_NAME, } from './embeddings.js';
 export { EmbeddingCache } from './embedding-cache.js';
 export { getEmbeddingFromServer, getServerStatus, isServerRunning, getServerPort, DEFAULT_PORT, HOST, TIMEOUT_MS, type ServerStatus, } from './embedding-client.js';
-export { initDB, getDB, getAdapter, closeDB, insertEmbedding, vectorSearch, queryVectorSearch, insertDecisionWithEmbedding, queryDecisionGraph, querySemanticEdges, updateDecisionOutcome, getPreparedStmt, getDbPath, type DatabaseAdapter as DBManagerAdapter, type PreparedStatement, type DecisionRecord, type OutcomeData, type VectorSearchParams, type SemanticEdges, type DecisionInput, } from './db-manager.js';
+export { initDB, getDB, getAdapter, closeDB, insertEmbedding, vectorSearch, queryVectorSearch, insertDecisionWithEmbedding, queryDecisionGraph, querySemanticEdges, updateDecisionOutcome, getPreparedStmt, getDbPath, type DatabaseAdapter as DBManagerAdapter, type PreparedStatement, type DecisionRecord, type OutcomeData, type VectorSearchParams, type SemanticEdges, type SemanticEdgeItem, type DecisionInput, } from './db-manager.js';
 export { createAdapter, DatabaseAdapter, SQLiteAdapter, type AdapterConfig, type Statement, type VectorSearchResult, type RunResult, } from './db-adapter/index.js';
 export { getSessionDecisions, incrementUsageSuccess, incrementUsageFailure, getDecisionById, traverseDecisionChain, DB_PATH, DB_DIR, LEGACY_DB_PATH, DEFAULT_DB_PATH, } from './memory-store.js';
 import mama from './mama-api.js';

package/dist/mama-api.d.ts

@@ -172,6 +172,9 @@ export interface LoadCheckpointResult {
  * Outcome badge map type
  */
 export type OutcomeBadgeMap = Record<string, string | null>;
+/**
+ * Raw semantic edge from database
+ */
 /**
  * Recall options
  */
@@ -412,7 +415,51 @@ declare function save({ topic, decision, reasoning, confidence, type, outcome, f
  * const markdown = await mama.recall('auth_strategy', { format: 'markdown' });
  * // → "📋 Decision History: auth_strategy\n━━━━━━━━..."
  */
-declare function recall(topic: string, options?: RecallOptions): Promise<unknown>;
+interface RecallEdgeRef {
+    to_topic?: string;
+    to_decision?: string;
+    to_id?: string;
+    from_topic?: string;
+    from_decision?: string;
+    from_id?: string;
+    reason?: string | null;
+    confidence?: number;
+    created_at?: string | number;
+}
+interface RecallGraphResult {
+    topic: string;
+    supersedes_chain: Array<{
+        id: string;
+        decision: string;
+        reasoning?: string | null;
+        confidence?: number;
+        outcome?: string | null;
+        failure_reason?: string | null;
+        created_at: number;
+        updated_at?: number;
+        superseded_by?: string | null;
+        supersedes?: string | null;
+    }>;
+    semantic_edges: {
+        refines: RecallEdgeRef[];
+        refined_by: RecallEdgeRef[];
+        contradicts: RecallEdgeRef[];
+        contradicted_by: RecallEdgeRef[];
+    };
+    meta: {
+        count: number;
+        latest_id?: string;
+        has_supersedes_chain: boolean;
+        has_semantic_edges: boolean;
+        semantic_edges_count: {
+            refines: number;
+            refined_by: number;
+            contradicts: number;
+            contradicted_by: number;
+        };
+    };
+}
+declare function recall(topic: string, options?: RecallOptions): Promise<string | RecallGraphResult>;
 /**
  * Update outcome of a decision
  *
@@ -505,13 +552,21 @@ declare function saveCheckpoint(summary: string, openFiles?: string[], nextSteps
  *
  * @returns {Promise<Object|null>} Latest checkpoint or null
  */
+interface ConversationMessage {
+    role: string;
+    content: string | Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}
 interface CheckpointRow {
     id?: number;
     timestamp?: number;
     summary?: string;
     open_files?: string | string[];
     next_steps?: string;
-    recent_conversation?: string | unknown[];
+    recent_conversation?: string | ConversationMessage[];
     status?: string;
 }
 declare function loadCheckpoint(): Promise<CheckpointRow | null>;

package/dist/mama-api.js

@@ -347,26 +347,6 @@ async function _getReasoningGraphInfo(topic, currentId) {
         };
     }
 }
-/**
- * Recall decisions by topic
- *
- * DEFAULT: Returns JSON object with decisions and edges (LLM-first design)
- * OPTIONAL: Returns Markdown string if format='markdown' (for human display)
- *
- * @param {string} topic - Decision topic to recall
- * @param {Object} [options] - Options
- * @param {string} [options.format='json'] - Output format: 'json' (default) or 'markdown'
- * @returns {Promise<Object|string>} Decision history as JSON or Markdown
- *
- * @example
- * // LLM usage (default)
- * const data = await mama.recall('auth_strategy');
- * // → { topic, decisions: [...], edges: [...], meta: {...} }
- *
- * // Human display
- * const markdown = await mama.recall('auth_strategy', { format: 'markdown' });
- * // → "📋 Decision History: auth_strategy\n━━━━━━━━..."
- */
 async function recall(topic, options = {}) {
     if (!topic || typeof topic !== 'string') {
         throw new Error('mama.recall() requires topic (string)');
@@ -382,18 +362,22 @@ async function recall(topic, options = {}) {
                 topic,
                 supersedes_chain: [],
                 semantic_edges: { refines: [], refined_by: [], contradicts: [], contradicted_by: [] },
-                meta: { count: 0 },
+                meta: {
+                    count: 0,
+                    has_supersedes_chain: false,
+                    has_semantic_edges: false,
+                    semantic_edges_count: { refines: 0, refined_by: 0, contradicts: 0, contradicted_by: 0 },
+                },
             };
         }
         // Query semantic edges for all decisions
         const decisionIds = decisions.map((d) => d.id);
-        const rawEdgesResult = await (0, memory_store_js_1.querySemanticEdges)(decisionIds);
-        const rawEdges = (rawEdgesResult || {});
+        const rawEdges = await (0, memory_store_js_1.querySemanticEdges)(decisionIds);
         const semanticEdges = {
-            refines: (rawEdges.refines || []),
-            refined_by: (rawEdges.refined_by || []),
-            contradicts: (rawEdges.contradicts || []),
-            contradicted_by: (rawEdges.contradicted_by || []),
+            refines: rawEdges.refines || [],
+            refined_by: rawEdges.refined_by || [],
+            contradicts: rawEdges.contradicts || [],
+            contradicted_by: rawEdges.contradicted_by || [],
         };
         // Markdown format (for human display)
         if (format === 'markdown') {
@@ -566,7 +550,6 @@ async function expandWithGraph(candidates) {
                 synthesized_by: rawEdges.synthesized_by || [],
             };
             // Helper to add edge to graph
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- dynamic property access with idField
             const addEdge = (edge, idField, source, rank, simFactor) => {
                 const id = edge[idField];
                 if (!graphEnhanced.has(id)) {
@@ -698,8 +681,10 @@ async function suggest(userQuestion, options = {}) {
         let results = [];
         let searchMethod = 'vector';
         try {
-            // Check if vectorSearch prepared statement exists
-            (0, memory_store_js_1.getPreparedStmt)('vectorSearch');
+            // Check if vector search is available (sqlite-vec loaded)
+            if (!(0, memory_store_js_1.getAdapter)().vectorSearchEnabled) {
+                throw new Error('Vector search not available');
+            }
             // Generate query embedding
             const queryEmbedding = await (0, embeddings_js_1.generateEmbedding)(userQuestion);
             // Adaptive threshold (shorter queries need higher confidence)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jungjaehoon/mama-core",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "MAMA Core - Shared modules for Memory-Augmented MCP Assistant",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",