oh-memos-mcp 1.0.0

package/dist/handlers/memory.js

@@ -0,0 +1,270 @@
+/**
+ * Memory Handlers
+ *
+ * memos_save, memos_list_v2, memos_get, memos_get_stats
+ */
+import * as crypto from "crypto";
+import { MEMOS_URL, MEMOS_USER, logger } from "../config.js";
+import { apiCallWithRetry } from "../api-client.js";
+import { ensureCubeRegistered } from "../cube-manager.js";
+import { formatMemoriesForDisplay } from "../formatters.js";
+import { PREVIEW_COUNT, shouldCompact, compactedResultToText, toMinimal, toFull, } from "../models.js";
+import { computeMemoryStats, extractMcpType } from "../query-processing.js";
+import { ERR_PARAM_MISSING, apiErrorResponse, cubeRegistrationError, errorResponse, getCubeIdFromArgs, } from "./utils.js";
+// ============================================================================
+// Deduplication Cache
+// ============================================================================
+const saveDedupCache = new Map();
+const DEDUP_TTL_SECONDS = 60;
+function contentHash(content, cubeId) {
+    return crypto.createHash("md5").update(`${cubeId}:${content}`).digest("hex");
+}
+function isDuplicateSave(content, cubeId) {
+    const key = contentHash(content, cubeId);
+    const now = Date.now() / 1000;
+    // Clean expired
+    for (const [k, [, ts]] of saveDedupCache) {
+        if (now - ts > DEDUP_TTL_SECONDS)
+            saveDedupCache.delete(k);
+    }
+    const entry = saveDedupCache.get(key);
+    if (entry && now - entry[1] < DEDUP_TTL_SECONDS) {
+        logger.debug(`Duplicate save detected (within ${DEDUP_TTL_SECONDS}s), skipping`);
+        return true;
+    }
+    return false;
+}
+function markSaved(content, cubeId) {
+    const key = contentHash(content, cubeId);
+    saveDedupCache.set(key, [cubeId, Date.now() / 1000]);
+}
+// ============================================================================
+// memos_save
+// ============================================================================
+export async function handleMemosSave(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    let content = String(arguments_.content ?? "");
+    const memoryType = arguments_.memory_type;
+    if (!memoryType) {
+        return errorResponse("memory_type parameter is required", ERR_PARAM_MISSING, [
+            "Bug fix -> `BUGFIX` or `ERROR_PATTERN`",
+            "Technical decision -> `DECISION`",
+            "Gotcha/trap -> `GOTCHA`",
+            "Code template -> `CODE_PATTERN`",
+            "Config change -> `CONFIG`",
+            "New feature -> `FEATURE`",
+            "Major achievement -> `MILESTONE`",
+            "Pure progress update -> `PROGRESS`",
+            'Example: `memos_save(content="...", memory_type="BUGFIX")`',
+        ]);
+    }
+    if (!content.startsWith(`[${memoryType}]`)) {
+        content = `[${memoryType}] ${content}`;
+    }
+    if (isDuplicateSave(content, cubeId)) {
+        return [{ type: "text", text: `⏭️ Skipped: Same content was saved within ${DEDUP_TTL_SECONDS}s (dedup protection)` }];
+    }
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    const result = await apiCallWithRetry("POST", `${MEMOS_URL}/memories`, cubeId, {
+        body: {
+            user_id: MEMOS_USER,
+            mem_cube_id: cubeId,
+            memory_content: content,
+        },
+    }, ensureCubeRegistered);
+    if (result.success) {
+        markSaved(content, cubeId);
+        return [{ type: "text", text: `Memory saved as [${memoryType}] in cube '${cubeId}'` }];
+    }
+    else if (result.data) {
+        return apiErrorResponse("Save", String(result.data.message ?? "Unknown error"));
+    }
+    else {
+        return apiErrorResponse("Save", `HTTP ${result.status}`);
+    }
+}
+// ============================================================================
+// memos_list_v2
+// ============================================================================
+export async function handleMemosList(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const limit = Number(arguments_.limit ?? 20);
+    const memoryType = arguments_.memory_type;
+    const compact = arguments_.compact !== false; // Default true
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    const params = {
+        user_id: MEMOS_USER,
+        mem_cube_id: cubeId,
+    };
+    if (!memoryType) {
+        params.limit = limit;
+    }
+    const result = await apiCallWithRetry("GET", `${MEMOS_URL}/memories`, cubeId, { params }, ensureCubeRegistered);
+    if (result.success && result.data) {
+        const resultData = result.data.data ?? {};
+        let allMemories = extractMemoriesFromData(resultData);
+        if (memoryType) {
+            allMemories = allMemories.filter((m) => extractMcpType(m) === memoryType).slice(0, limit);
+        }
+        const totalCount = allMemories.length;
+        if (compact && shouldCompact(totalCount)) {
+            const preview = allMemories.slice(0, PREVIEW_COUNT).map(toMinimal);
+            const text = compactedResultToText({
+                preview,
+                totalCount,
+                omittedCount: totalCount - preview.length,
+                message: 'Use memos_get(memory_id="<id>") for full details',
+                query: memoryType ? `list (type=${memoryType})` : "list all",
+                cubeId,
+            });
+            return [{ type: "text", text }];
+        }
+        const formatted = formatMemoriesForDisplay(resultData);
+        return [{ type: "text", text: formatted }];
+    }
+    else if (result.data) {
+        return apiErrorResponse("List", String(result.data.message ?? "Unknown error"));
+    }
+    else {
+        return apiErrorResponse("List", `HTTP ${result.status}`);
+    }
+}
+// ============================================================================
+// memos_get
+// ============================================================================
+export async function handleMemosGet(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const memoryId = String(arguments_.memory_id ?? "");
+    if (!memoryId) {
+        return errorResponse("memory_id parameter is required", ERR_PARAM_MISSING, [
+            "Get memory_id from memos_search or memos_list_v2 results",
+            'Example: `memos_get(memory_id="abc123-...")`',
+        ]);
+    }
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    const result = await apiCallWithRetry("GET", `${MEMOS_URL}/memories/${cubeId}/${memoryId}`, cubeId, {}, ensureCubeRegistered);
+    if (result.success && result.data) {
+        const resultData = result.data.data;
+        if (resultData) {
+            const fullMem = toFull(resultData, cubeId, MEMOS_USER);
+            const lines = [
+                "## 📝 Memory Details",
+                "",
+                `**ID**: \`${fullMem.id}\``,
+                `**Type**: ${fullMem.memoryType}`,
+                `**Cube**: ${fullMem.cubeId}`,
+            ];
+            if (fullMem.key)
+                lines.push(`**Key**: ${fullMem.key}`);
+            if (fullMem.tags.length > 0)
+                lines.push(`**Tags**: ${fullMem.tags.join(", ")}`);
+            if (fullMem.createdAt)
+                lines.push(`**Created**: ${fullMem.createdAt}`);
+            lines.push("", "### Content", "", fullMem.content);
+            if (fullMem.background) {
+                lines.push("", "### Background", "", fullMem.background);
+            }
+            if (fullMem.relations && fullMem.relations.length > 0) {
+                lines.push("", "### Relations", "");
+                for (const rel of fullMem.relations.slice(0, 5)) {
+                    lines.push(`- ${JSON.stringify(rel)}`);
+                }
+            }
+            return [{ type: "text", text: lines.join("\n") }];
+        }
+        else {
+            return [{ type: "text", text: notFoundText(memoryId) }];
+        }
+    }
+    else if (result.data) {
+        const errMsg = String(result.data.message ?? "Unknown error");
+        if (errMsg.toLowerCase().includes("not found") || result.status === 404) {
+            return [{ type: "text", text: notFoundText(memoryId) }];
+        }
+        return apiErrorResponse("Get", errMsg);
+    }
+    else {
+        return apiErrorResponse("Get", `HTTP ${result.status}`);
+    }
+}
+function notFoundText(memoryId) {
+    return [
+        `❌ Memory not found: \`${memoryId}\``,
+        "",
+        "💡 **Tips**:",
+        "- Verify the ID is correct (copy from memos_search results)",
+        "- The memory may have been deleted",
+        "- Try `memos_search` to find the memory again",
+    ].join("\n");
+}
+// ============================================================================
+// memos_get_stats
+// ============================================================================
+export async function handleMemosGetStats(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    const result = await apiCallWithRetry("GET", `${MEMOS_URL}/memories`, cubeId, { params: { user_id: MEMOS_USER, mem_cube_id: cubeId } }, ensureCubeRegistered);
+    if (result.success && result.data) {
+        const [stats, total] = computeMemoryStats(result.data.data ?? {});
+        if (total === 0) {
+            return [{ type: "text", text: `No memories found in cube '${cubeId}'.` }];
+        }
+        const typeIcons = {
+            BUGFIX: "🐛", ERROR_PATTERN: "🔴", DECISION: "📋",
+            GOTCHA: "⚠️", CODE_PATTERN: "📝", CONFIG: "⚙️",
+            FEATURE: "✨", MILESTONE: "🎯", PROGRESS: "📊", INFERRED: "🔗",
+        };
+        const result_lines = [`## 📊 Memory Stats: ${cubeId}`, `Total Memories: **${total}**`, ""];
+        for (const [mtype, count] of Object.entries(stats).sort((a, b) => b[1] - a[1])) {
+            const percentage = (count / total * 100).toFixed(1);
+            const icon = typeIcons[mtype] ?? "📌";
+            result_lines.push(`- ${icon} **${mtype}**: ${count} (${percentage}%)`);
+        }
+        const inferredCount = stats.INFERRED ?? 0;
+        const progressCount = stats.PROGRESS ?? 0;
+        const userTyped = total - inferredCount - progressCount;
+        if (inferredCount > 0) {
+            result_lines.push("", "---", "", `ℹ️ **INFERRED** (${inferredCount} 条): 图数据库自动生成的因果推断节点，非用户保存，属正常现象。`);
+        }
+        if (total > 0 && progressCount / total > 0.5) {
+            result_lines.push("", "---", "", `⚠️ **PROGRESS 占比偏高** (${progressCount}/${total}): 保存时建议显式指定类型:`);
+            result_lines.push("   `BUGFIX` · `DECISION` · `MILESTONE` · `FEATURE` · `GOTCHA` · `CONFIG`");
+        }
+        if (userTyped > 0) {
+            result_lines.push("", `✅ **用户标注记忆**: ${userTyped} 条 (${(userTyped / total * 100).toFixed(0)}%)`);
+        }
+        return [{ type: "text", text: result_lines.join("\n") }];
+    }
+    else if (result.data) {
+        return apiErrorResponse("Stats", String(result.data.message ?? "Unknown error"));
+    }
+    else {
+        return apiErrorResponse("Stats", `HTTP ${result.status}`);
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+export function extractMemoriesFromData(data) {
+    const memories = [];
+    const textMems = data.text_mem ?? [];
+    for (const cubeData of textMems) {
+        const memData = cubeData.memories;
+        if (memData && !Array.isArray(memData) && memData.nodes) {
+            memories.push(...memData.nodes);
+        }
+        else if (Array.isArray(memData)) {
+            memories.push(...memData);
+        }
+    }
+    return memories;
+}
+//# sourceMappingURL=memory.js.map

package/dist/handlers/search.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Search Handlers
+ *
+ * memos_search, memos_search_context, memos_suggest, memos_context_resume
+ */
+import type { TextContent } from "../types.js";
+export declare function handleMemosSearch(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosSearchContext(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosSuggest(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosContextResume(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+//# sourceMappingURL=search.d.ts.map

package/dist/handlers/search.js

@@ -0,0 +1,334 @@
+/**
+ * Search Handlers
+ *
+ * memos_search, memos_search_context, memos_suggest, memos_context_resume
+ */
+import { MEMOS_URL, MEMOS_USER, NEO4J_HTTP_URL, NEO4J_USER, NEO4J_PASSWORD, logger } from "../config.js";
+import { apiCallWithRetry, fetchWithTimeout } from "../api-client.js";
+import { ensureCubeRegistered } from "../cube-manager.js";
+import { formatMemoriesForDisplay } from "../formatters.js";
+import { PREVIEW_COUNT, shouldCompact, compactedResultToText, toMinimal, } from "../models.js";
+import { applyKeywordRerank, detectQueryIntent, filterEdgesByIntent, filterMemoriesByType, getIntentDescription, parseMemoryTypePrefix, } from "../query-processing.js";
+import { suggestSearchQueries } from "../memory-analysis.js";
+import { apiErrorResponse, cubeRegistrationError, getCubeIdFromArgs, } from "./utils.js";
+// ============================================================================
+// Temporal Graph Query (Neo4j)
+// ============================================================================
+async function getTemporalMemories(cubeId, topK = 10, timeWindowHours) {
+    if (!NEO4J_HTTP_URL || !NEO4J_USER || !NEO4J_PASSWORD) {
+        logger.debug("Neo4j config missing, skipping temporal query");
+        return [];
+    }
+    const auth = Buffer.from(`${NEO4J_USER}:${NEO4J_PASSWORD}`).toString("base64");
+    const timeFilter = timeWindowHours
+        ? `AND n.updated_at >= datetime() - duration({hours: ${timeWindowHours}})`
+        : "";
+    const cypher = `
+    MATCH (n:Memory)
+    WHERE n.user_name = $user_name
+    AND n.status = 'activated'
+    ${timeFilter}
+    RETURN n.id AS id, n.memory AS memory, n.key AS key,
+           n.updated_at AS updated_at, n.background AS background,
+           n.tags AS tags
+    ORDER BY n.updated_at DESC
+    LIMIT $top_k
+  `;
+    try {
+        const response = await fetchWithTimeout(NEO4J_HTTP_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Basic ${auth}`,
+            },
+            body: JSON.stringify({
+                statements: [
+                    {
+                        statement: cypher,
+                        parameters: { user_name: MEMOS_USER, top_k: topK },
+                    },
+                ],
+            }),
+            timeoutMs: 10,
+        });
+        if (response.ok) {
+            const data = await response.json();
+            const errors = data.errors ?? [];
+            if (errors.length > 0) {
+                logger.warning(`Neo4j temporal query errors: ${JSON.stringify(errors)}`);
+                return [];
+            }
+            const rows = (data.results?.[0]?.data ?? []);
+            const memories = [];
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                const r = row.row ?? [];
+                if (r.length >= 4) {
+                    memories.push({
+                        id: String(r[0] ?? ""),
+                        memory: String(r[1] ?? ""),
+                        key: String(r[2] ?? ""),
+                        updated_at: String(r[3] ?? ""),
+                        background: r.length > 4 ? String(r[4] ?? "") : "",
+                        tags: Array.isArray(r[5]) ? r[5] : [],
+                        metadata: {
+                            relativity: 0.8 - i * 0.05,
+                            temporal_rank: i + 1,
+                            source: "temporal_query",
+                        },
+                    });
+                }
+            }
+            logger.info(`Temporal query returned ${memories.length} memories`);
+            return memories;
+        }
+    }
+    catch (err) {
+        logger.error(`Temporal query error: ${err}`);
+    }
+    return [];
+}
+function mergeTemporalResults(searchData, temporalMemories, intent) {
+    if (temporalMemories.length === 0)
+        return searchData;
+    const existingIds = new Set();
+    const textMem = searchData.text_mem ?? [];
+    for (const bucket of textMem) {
+        const memData = bucket.memories;
+        const memories = Array.isArray(memData)
+            ? memData
+            : (memData?.nodes ?? []);
+        for (const mem of memories) {
+            const id = mem.id ?? mem.metadata?.id;
+            if (id)
+                existingIds.add(id);
+        }
+    }
+    const newTemporal = temporalMemories.filter((m) => !existingIds.has(m.id));
+    if (newTemporal.length === 0)
+        return searchData;
+    if (intent === "temporal") {
+        const temporalBucket = {
+            cube_id: "temporal",
+            memories: { nodes: newTemporal, edges: [] },
+            _source: "temporal_graph_query",
+        };
+        searchData.text_mem = [temporalBucket, ...textMem];
+    }
+    return searchData;
+}
+function extractSearchMemories(data) {
+    const memories = [];
+    for (const cubeData of data.text_mem ?? []) {
+        const memData = cubeData.memories;
+        if (memData && !Array.isArray(memData) && memData.nodes) {
+            memories.push(...memData.nodes);
+        }
+        else if (Array.isArray(memData)) {
+            memories.push(...memData);
+        }
+    }
+    return memories;
+}
+// ============================================================================
+// memos_search
+// ============================================================================
+export async function handleMemosSearch(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const rawQuery = String(arguments_.query ?? "");
+    const topK = Number(arguments_.top_k ?? 10);
+    const compact = arguments_.compact !== false;
+    const [memType, cleanedQuery] = parseMemoryTypePrefix(rawQuery);
+    const query = cleanedQuery || rawQuery;
+    const intent = detectQueryIntent(query);
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    const apiResult = await apiCallWithRetry("POST", `${MEMOS_URL}/search`, cubeId, {
+        body: {
+            user_id: MEMOS_USER,
+            query,
+            install_cube_ids: [cubeId],
+            top_k: topK,
+        },
+    }, ensureCubeRegistered);
+    if (apiResult.success && apiResult.data) {
+        let resultData = apiResult.data.data ?? {};
+        // Temporal enhancement
+        if (intent === "temporal") {
+            let timeWindow;
+            const timeMatch = query.match(/(\d+)\s*(?:小时|hour|h)/i);
+            if (timeMatch)
+                timeWindow = parseInt(timeMatch[1]);
+            else if (/今天|today/i.test(query))
+                timeWindow = 24;
+            else if (/本周|this\s*week|week/i.test(query))
+                timeWindow = 168;
+            const temporalMemories = await getTemporalMemories(cubeId, topK, timeWindow);
+            resultData = mergeTemporalResults(resultData, temporalMemories, intent);
+        }
+        resultData = filterEdgesByIntent(resultData, intent);
+        resultData = filterMemoriesByType(resultData, memType);
+        const keywordQuery = memType ? cleanedQuery : query;
+        resultData = applyKeywordRerank(resultData, keywordQuery);
+        const allMemories = extractSearchMemories(resultData);
+        const totalCount = allMemories.length;
+        if (compact && shouldCompact(totalCount)) {
+            const preview = allMemories.slice(0, PREVIEW_COUNT).map(toMinimal);
+            let text = compactedResultToText({
+                preview,
+                totalCount,
+                omittedCount: totalCount - preview.length,
+                message: 'Use memos_get(memory_id="<id>") for full details',
+                query: rawQuery,
+                cubeId,
+            });
+            if (intent !== "default") {
+                const intentDesc = getIntentDescription(intent);
+                text = `*${intentDesc}*\n\n${text}`;
+            }
+            return [{ type: "text", text }];
+        }
+        let formatted = formatMemoriesForDisplay(resultData);
+        if (intent !== "default") {
+            const intentDesc = getIntentDescription(intent);
+            formatted = `*${intentDesc}*\n\n${formatted}`;
+        }
+        return [{ type: "text", text: formatted }];
+    }
+    else if (apiResult.data) {
+        return apiErrorResponse("Search", String(apiResult.data.message ?? "Unknown error"));
+    }
+    else {
+        return apiErrorResponse("Search", `HTTP ${apiResult.status}`);
+    }
+}
+// ============================================================================
+// memos_search_context
+// ============================================================================
+export async function handleMemosSearchContext(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const rawQuery = String(arguments_.query ?? "");
+    const context = arguments_.context ?? [];
+    const [memType, cleanedQuery] = parseMemoryTypePrefix(rawQuery);
+    const query = cleanedQuery || rawQuery;
+    const contextText = context.slice(-5).map((m) => m.content ?? "").join(" ");
+    const intent = detectQueryIntent(`${query} ${contextText}`);
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    const chatHistory = context.slice(-10)
+        .filter((m) => m.content)
+        .map((m) => ({ role: m.role, content: m.content }));
+    try {
+        const response = await fetchWithTimeout(`${MEMOS_URL}/search`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                user_id: MEMOS_USER,
+                query,
+                readable_cube_ids: [cubeId],
+                enable_context_analysis: true,
+                chat_history: chatHistory,
+                top_k: 15,
+            }),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            if (data.code === 200) {
+                const results = [];
+                const intentDesc = getIntentDescription(intent);
+                results.push(`## ${intentDesc}`, "");
+                let resultData = data.data ?? {};
+                if (intent === "temporal") {
+                    const temporalMemories = await getTemporalMemories(cubeId, 15);
+                    resultData = mergeTemporalResults(resultData, temporalMemories, intent);
+                }
+                resultData = filterEdgesByIntent(resultData, intent);
+                resultData = filterMemoriesByType(resultData, memType);
+                const keywordQuery = memType ? cleanedQuery : query;
+                resultData = applyKeywordRerank(resultData, keywordQuery);
+                const formatted = formatMemoriesForDisplay(resultData);
+                if (context.length > 0) {
+                    results.push(`*Analyzed with ${context.length} context messages*`, "");
+                }
+                results.push(formatted);
+                return [{ type: "text", text: results.join("\n") }];
+            }
+            else {
+                // Fallback to standard search
+                const fallbackResult = await apiCallWithRetry("POST", `${MEMOS_URL}/search`, cubeId, { body: { user_id: MEMOS_USER, query, install_cube_ids: [cubeId] } }, ensureCubeRegistered);
+                if (fallbackResult.success && fallbackResult.data) {
+                    let resultData = fallbackResult.data.data ?? {};
+                    resultData = filterEdgesByIntent(resultData, intent);
+                    resultData = filterMemoriesByType(resultData, memType);
+                    const keywordQuery = memType ? cleanedQuery : query;
+                    resultData = applyKeywordRerank(resultData, keywordQuery);
+                    const formatted = formatMemoriesForDisplay(resultData);
+                    return [{ type: "text", text: `## Search Results (fallback)\n\n${formatted}` }];
+                }
+                return apiErrorResponse("Context search", String(data.message ?? "Unknown error"));
+            }
+        }
+        else {
+            return apiErrorResponse("Context search", `HTTP ${response.status}`);
+        }
+    }
+    catch (err) {
+        return apiErrorResponse("Context search", String(err));
+    }
+}
+// ============================================================================
+// memos_suggest
+// ============================================================================
+export async function handleMemosSuggest(arguments_) {
+    const context = String(arguments_.context ?? "");
+    const suggestions = suggestSearchQueries(context);
+    if (suggestions.length > 0) {
+        const result = ["## 🔍 Suggested Searches\n", "Based on your context, try these searches:\n"];
+        for (let i = 0; i < suggestions.length; i++) {
+            result.push(`${i + 1}. \`${suggestions[i]}\``);
+        }
+        return [{ type: "text", text: result.join("\n") }];
+    }
+    else {
+        return [{ type: "text", text: "No specific suggestions. Try searching with keywords from your context." }];
+    }
+}
+// ============================================================================
+// memos_context_resume
+// ============================================================================
+export async function handleMemosContextResume(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    // Try temporal query first
+    let recentMemories = await getTemporalMemories(cubeId, 10, 24);
+    // Fallback to API list
+    if (recentMemories.length === 0) {
+        const result = await apiCallWithRetry("GET", `${MEMOS_URL}/memories`, cubeId, { params: { user_id: MEMOS_USER, mem_cube_id: cubeId, limit: 10 } }, ensureCubeRegistered);
+        if (result.success && result.data) {
+            recentMemories = extractSearchMemories(result.data.data ?? {});
+        }
+    }
+    const lines = ["## Context Resumed", ""];
+    if (recentMemories.length > 0) {
+        lines.push(`**Recent memories** (${recentMemories.length} items, last 24h):`, "");
+        for (let i = 0; i < Math.min(recentMemories.length, 10); i++) {
+            const mem = recentMemories[i];
+            const content = mem.memory ?? "";
+            const summary = content.slice(0, 120).split("\n")[0];
+            lines.push(`${i + 1}. ${summary}`);
+        }
+        lines.push("");
+    }
+    else {
+        lines.push("No recent memories found in this cube.", "");
+    }
+    lines.push("---");
+    lines.push("**REMINDER**: Use MCP memos tools (`memos_save`, `memos_search`) for ALL memory operations.");
+    lines.push("NEVER use `mkdir` or `Write` to create memory files.");
+    return [{ type: "text", text: lines.join("\n") }];
+}
+//# sourceMappingURL=search.js.map

package/dist/handlers/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Handler Utilities
+ *
+ * Shared error formatting and cube ID resolution.
+ */
+import type { TextContent } from "../types.js";
+export declare const ERR_API_UNREACHABLE = "API_UNREACHABLE";
+export declare const ERR_API_ERROR = "API_ERROR";
+export declare const ERR_CUBE_NOT_FOUND = "CUBE_NOT_FOUND";
+export declare const ERR_CUBE_REGISTRATION = "CUBE_REGISTRATION_FAILED";
+export declare const ERR_PARAM_MISSING = "PARAM_MISSING";
+export declare const ERR_PARAM_INVALID = "PARAM_INVALID";
+export declare const ERR_NEO4J_CONFIG = "NEO4J_CONFIG_MISSING";
+export declare const ERR_OPERATION_FAILED = "OPERATION_FAILED";
+export declare const ERR_DELETE_DISABLED = "DELETE_DISABLED";
+export declare const ERR_USER_ERROR = "USER_ERROR";
+export declare function errorResponse(message: string, errorCode?: string, suggestions?: string[]): TextContent[];
+export declare function successResponse(message: string): TextContent[];
+export declare function cubeRegistrationError(cubeId: string, detail: string | null): TextContent[];
+export declare function apiErrorResponse(operation: string, statusOrMsg: string | number): TextContent[];
+export declare function getCubeIdFromArgs(arguments_: Record<string, unknown>): string;
+//# sourceMappingURL=utils.d.ts.map