oh-memos-mcp 1.0.0

package/dist/handlers/utils.js

@@ -0,0 +1,75 @@
+/**
+ * Handler Utilities
+ *
+ * Shared error formatting and cube ID resolution.
+ */
+import { detectCubeFromPath } from "../keyword-enhancer.js";
+import { getDefaultCubeId } from "../cube-manager.js";
+// ============================================================================
+// Error Codes
+// ============================================================================
+export const ERR_API_UNREACHABLE = "API_UNREACHABLE";
+export const ERR_API_ERROR = "API_ERROR";
+export const ERR_CUBE_NOT_FOUND = "CUBE_NOT_FOUND";
+export const ERR_CUBE_REGISTRATION = "CUBE_REGISTRATION_FAILED";
+export const ERR_PARAM_MISSING = "PARAM_MISSING";
+export const ERR_PARAM_INVALID = "PARAM_INVALID";
+export const ERR_NEO4J_CONFIG = "NEO4J_CONFIG_MISSING";
+export const ERR_OPERATION_FAILED = "OPERATION_FAILED";
+export const ERR_DELETE_DISABLED = "DELETE_DISABLED";
+export const ERR_USER_ERROR = "USER_ERROR";
+// ============================================================================
+// Response Helpers
+// ============================================================================
+export function errorResponse(message, errorCode, suggestions) {
+    const parts = [];
+    if (errorCode) {
+        parts.push(`❌ [${errorCode}] ${message}`);
+    }
+    else {
+        parts.push(`❌ ${message}`);
+    }
+    if (suggestions && suggestions.length > 0) {
+        parts.push("");
+        parts.push("💡 Suggestions:");
+        for (const s of suggestions) {
+            parts.push(`- ${s}`);
+        }
+    }
+    return [{ type: "text", text: parts.join("\n") }];
+}
+export function successResponse(message) {
+    return [{ type: "text", text: message }];
+}
+export function cubeRegistrationError(cubeId, detail) {
+    return errorResponse(`Cube '${cubeId}' registration failed: ${detail ?? "unknown error"}`, ERR_CUBE_REGISTRATION, [
+        `Check if MemOS API is running: \`curl http://localhost:18000/health\``,
+        `Verify cube exists: \`memos_list_cubes(include_status=True)\``,
+        `Try manual registration: \`memos_register_cube(cube_id="...")\``,
+    ]);
+}
+export function apiErrorResponse(operation, statusOrMsg) {
+    return errorResponse(`${operation} failed: ${statusOrMsg}`, ERR_API_ERROR, [
+        "Check API health: `curl http://localhost:18000/health/detail`",
+        "Check API logs for details",
+    ]);
+}
+// ============================================================================
+// Cube ID Resolution
+// ============================================================================
+export function getCubeIdFromArgs(arguments_) {
+    const argCubeId = arguments_.cube_id;
+    const projectPath = arguments_.project_path;
+    if (projectPath) {
+        try {
+            const derived = detectCubeFromPath(projectPath);
+            if (derived)
+                return derived;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return argCubeId ?? getDefaultCubeId();
+}
+//# sourceMappingURL=utils.js.map

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * oh-memos-mcp — MCP Server for MemOS Intelligent Memory Management
+ *
+ * Usage:
+ *   npx oh-memos-mcp
+ *   node dist/index.js
+ *
+ * Configuration via environment variables or CLI args.
+ * See README.md for full documentation.
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * oh-memos-mcp — MCP Server for MemOS Intelligent Memory Management
+ *
+ * Usage:
+ *   npx oh-memos-mcp
+ *   node dist/index.js
+ *
+ * Configuration via environment variables or CLI args.
+ * See README.md for full documentation.
+ */
+import { runServer } from "./server.js";
+import { logger } from "./config.js";
+runServer().catch((err) => {
+    logger.error(`Fatal error: ${err}`);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/keyword-enhancer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Keyword Enhancer Module
+ *
+ * - Extended stopwords (programming/technical + Chinese)
+ * - Fuzzy matching with Levenshtein distance
+ * - Smart cube auto-detection from project path
+ * - Structured field weighting
+ */
+export declare const ENGLISH_STOPWORDS: Set<string>;
+export declare const CHINESE_STOPWORDS: Set<string>;
+export declare const ALL_STOPWORDS: Set<string>;
+export declare function levenshteinDistance(s1: string, s2: string): number;
+export declare function fuzzyMatchScore(query: string, text: string, threshold?: number): number;
+export declare function findFuzzyMatches(keyword: string, text: string, threshold?: number, maxWordLenDiff?: number): Array<[string, number]>;
+export declare function detectCubeFromPath(projectPath?: string): string;
+export declare function extractKeywordsEnhanced(query: string, stopwords?: Set<string>, minLength?: number): string[];
+export declare function keywordMatchScoreEnhanced(text: string, keywords: string[], metadata?: Record<string, unknown>, enableFuzzy?: boolean, fuzzyThreshold?: number): number;
+//# sourceMappingURL=keyword-enhancer.d.ts.map

package/dist/keyword-enhancer.js

@@ -0,0 +1,335 @@
+/**
+ * Keyword Enhancer Module
+ *
+ * - Extended stopwords (programming/technical + Chinese)
+ * - Fuzzy matching with Levenshtein distance
+ * - Smart cube auto-detection from project path
+ * - Structured field weighting
+ */
+// =============================================================================
+// Extended Stopwords
+// =============================================================================
+export const ENGLISH_STOPWORDS = new Set([
+    // General English
+    "the", "and", "or", "a", "an", "to", "of", "for", "with", "in", "on",
+    "at", "is", "are", "was", "were", "be", "been", "being", "this", "that",
+    "it", "as", "from", "by", "about", "into", "over", "after", "before",
+    "not", "but", "if", "then", "else", "when", "where", "which", "who",
+    "whom", "whose", "why", "how", "all", "each", "every", "both", "few",
+    "more", "most", "other", "some", "such", "no", "nor", "only", "own",
+    "same", "so", "than", "too", "very", "just", "can", "will", "should",
+    "would", "could", "may", "might", "must", "shall", "do", "does", "did",
+    "doing", "done", "have", "has", "had", "having", "get", "got", "gets",
+    "getting", "make", "makes", "made", "making", "go", "goes", "went",
+    "going", "come", "comes", "came", "coming", "take", "takes", "took",
+    "taking", "see", "sees", "saw", "seeing", "know", "knows", "knew",
+    "knowing", "think", "thinks", "thought", "thinking", "want", "wants",
+    "wanted", "wanting", "use", "uses", "used", "using", "find", "finds",
+    "found", "finding", "give", "gives", "gave", "giving", "tell", "tells",
+    "told", "telling", "say", "says", "said", "saying", "try", "tries",
+    "tried", "trying", "need", "needs", "needed", "needing", "let", "lets",
+    "put", "puts", "keep", "keeps", "kept", "keeping", "begin", "begins",
+    "began", "beginning", "show", "shows", "showed", "showing",
+    // Programming common words (usually not meaningful for search)
+    "todo", "fixme", "hack", "note", "xxx", "temp", "tmp", "foo", "bar",
+    "baz", "qux", "test", "example", "sample", "demo", "main", "index",
+    "app", "application", "module", "package", "import", "export", "require",
+    "define", "declare", "const", "var", "function", "class", "method",
+    "return", "void", "null", "undefined", "true", "false", "new", "delete",
+    "typeof", "instanceof", "catch", "finally", "throw", "async",
+    "await", "yield", "public", "private", "protected", "static", "final",
+    "abstract", "interface", "extends", "implements", "super", "self", "cls",
+    "args", "kwargs", "param", "params", "arg", "argument", "arguments",
+    "value", "values", "result", "results", "data", "info", "item", "items",
+    "list", "array", "object", "dict", "map", "tuple", "string",
+    "str", "int", "float", "bool", "boolean", "number", "num", "char",
+    "byte", "bytes", "type", "types", "name", "names", "key", "keys",
+    "val", "vals", "obj", "objs", "elem", "elems", "element", "elements",
+    "node", "nodes", "attr", "attrs", "attribute", "attributes", "prop",
+    "props", "property", "properties", "opt", "opts", "option", "options",
+    "cfg", "conf", "config", "configuration", "setting", "settings",
+    "env", "environment", "ctx", "context", "req", "request", "res",
+    "response", "err", "error", "errors", "msg", "message", "messages",
+    "log", "logs", "debug", "warn", "warning", "warnings", "input", "output",
+    "out", "src", "source", "dest", "destination", "target", "path", "paths",
+    "file", "files", "dir", "directory", "directories", "folder", "folders",
+    "url", "urls", "uri", "uris", "id", "ids", "uid", "uuid", "guid",
+    "ref", "refs", "reference", "references", "ptr", "pointer", "pointers",
+    "handle", "handles", "callback", "callbacks", "handler", "handlers",
+    "listener", "listeners", "event", "events", "action", "actions",
+    "state", "states", "status", "flag", "flags", "mode", "modes",
+    "level", "levels", "size", "sizes", "length", "len", "count", "counts",
+    "total", "sum", "avg", "average", "min", "max", "first", "last",
+    "prev", "previous", "next", "current", "cur", "old", "start", "end",
+    "init", "initialize", "initialized", "setup", "teardown", "cleanup",
+    "reset", "clear", "load", "save", "post", "update", "remove", "insert",
+    "append", "push", "pop", "shift", "unshift", "sub", "mul", "div",
+    "mod", "xor", "bit", "bits", "word", "words", "line", "lines",
+    "row", "rows", "col", "column", "columns", "cell", "cells", "grid",
+    "grids", "table", "tables", "record", "records", "field", "fields",
+    "schema", "schemas", "model", "models", "view", "views", "controller",
+    "controllers", "service", "services", "repository", "repositories",
+    "factory", "factories", "builder", "builders", "adapter", "adapters",
+    "wrapper", "wrappers", "helper", "helpers", "util", "utils", "utility",
+    "utilities", "tool", "tools", "lib", "library", "libraries", "framework",
+    "frameworks", "plugin", "plugins", "extension", "extensions",
+    "component", "components", "widget", "widgets", "block", "blocks",
+    "section", "sections", "part", "parts", "piece", "pieces", "chunk",
+    "chunks", "segment", "segments", "unit", "units", "modules", "system",
+    "systems", "layer", "layers", "process", "processes", "thread", "threads",
+    "task", "tasks", "job", "jobs", "work", "works", "worker", "workers",
+    "queue", "queues", "stack", "stacks", "pool", "pools", "cache", "caches",
+    "buffer", "buffers", "stream", "streams", "pipe", "pipes", "channel",
+    "channels", "socket", "sockets", "port", "ports", "host", "hosts",
+    "server", "servers", "client", "clients", "user", "users", "admin",
+    "admins", "root", "guest", "account", "accounts", "profile", "profiles",
+    "session", "sessions", "token", "tokens", "auth", "authentication",
+    "authorization", "permission", "permissions", "role", "roles", "access",
+    "grant", "grants", "deny", "denies", "filter", "filters",
+    "validate", "validates", "validation", "check", "checks", "verify",
+    "verifies", "verification", "confirm", "confirms", "confirmation",
+    "approve", "approves", "approval", "reject", "rejects", "rejection",
+    "accept", "accepts", "acceptance", "decline", "declines", "cancel",
+    "cancels", "cancellation", "abort", "aborts", "retry", "retries",
+    "timeout", "timeouts", "expire", "expires", "expiration",
+    "refresh", "refreshes", "renew", "renews", "renewal",
+]);
+export const CHINESE_STOPWORDS = new Set([
+    "的", "了", "和", "与", "在", "是", "有", "我", "你", "他", "她", "它",
+    "我们", "你们", "他们", "她们", "它们", "这", "那", "这个", "那个",
+    "这些", "那些", "这里", "那里", "这儿", "那儿", "什么", "怎么", "怎样",
+    "如何", "为什么", "哪", "哪个", "哪些", "哪里", "哪儿", "谁", "多少",
+    "几", "多", "少", "大", "小", "好", "坏", "对", "错", "行", "不行",
+    "可以", "不可以", "能", "不能", "会", "不会", "要", "不要", "想",
+    "不想", "应该", "不应该", "必须", "不必", "可能", "不可能", "一定",
+    "也许", "或许", "大概", "肯定", "当然", "确实", "真的", "假的",
+    "及", "或", "或者", "还是", "以及", "并", "并且", "而",
+    "而且", "但", "但是", "不过", "然而", "可是", "虽然", "尽管", "即使",
+    "如果", "假如", "要是", "只要", "除非", "无论", "不管", "不论",
+    "因为", "由于", "所以", "因此", "因而", "于是", "那么", "这样",
+    "既然", "只有", "才", "就", "便", "却", "倒", "反而", "否则",
+    "不然", "要不", "要不然", "要么", "以便", "以免", "以致", "为了",
+    "为着", "对于", "关于", "至于", "根据", "按照", "依照", "通过",
+    "经过", "随着", "沿着", "顺着", "朝着", "向着", "趁着", "除了",
+    "除开", "除去", "除却", "除外",
+    "自己", "自身", "本人", "本身", "彼此", "相互", "互相", "大家",
+    "各位", "诸位", "各自", "某", "某个", "某些", "其", "其中", "其他",
+    "其它", "其余", "另", "另外", "另一", "别", "别的", "任何", "一切",
+    "所有", "全部", "整个", "每", "每个", "各", "各个", "同", "同一",
+    "同样", "一样", "一般", "一种", "某种", "这种", "那种", "各种",
+    "现在", "目前", "当前", "眼前", "此时", "此刻", "刚才", "方才",
+    "刚刚", "正在", "正", "将", "将要", "快要", "就要", "已经", "已",
+    "曾", "曾经", "过去", "以前", "之前", "以后", "之后", "后来", "然后",
+    "接着", "继而", "随后", "最后", "最终", "终于", "始终", "一直",
+    "常常", "经常", "往往", "总是", "老是", "有时", "有时候", "偶尔",
+    "突然", "忽然", "马上", "立刻", "立即", "赶紧", "赶快", "连忙",
+    "从来", "一向", "向来", "素来", "历来", "原来", "本来", "起初",
+    "很", "非常", "十分", "极", "极其", "极为", "特别", "尤其", "格外",
+    "更", "更加", "越", "越发", "越来越", "最", "顶", "太", "过于",
+    "稍", "稍微", "略", "略微", "比较", "相当", "相对", "颇", "挺",
+    "不", "没", "没有", "未", "尚未", "并不", "并非", "并没", "并没有",
+    "也", "还", "又", "再", "仍", "仍然", "依然", "依旧", "照样",
+    "都", "全", "全都", "皆", "均", "统统", "通通", "一概", "一律",
+    "只", "只是", "仅", "仅仅", "光", "单", "单独",
+    "啊", "呀", "哇", "哦", "噢", "哎", "唉", "嗨", "喂", "嘿",
+    "嗯", "哼", "吧", "呢", "吗", "嘛", "啦", "喽", "呗",
+    "罢了", "而已", "罢", "地", "得", "着", "过", "们",
+    "做", "用", "把", "被", "给", "让", "叫", "使",
+    "令", "请", "来", "去", "到", "进", "出", "上", "下", "起", "开",
+    "关", "拿", "放", "看", "听", "说", "写", "读",
+]);
+export const ALL_STOPWORDS = new Set([
+    ...ENGLISH_STOPWORDS,
+    ...CHINESE_STOPWORDS,
+]);
+// =============================================================================
+// Fuzzy Matching
+// =============================================================================
+export function levenshteinDistance(s1, s2) {
+    if (s1.length < s2.length) {
+        [s1, s2] = [s2, s1];
+    }
+    if (s2.length === 0)
+        return s1.length;
+    let previousRow = Array.from({ length: s2.length + 1 }, (_, i) => i);
+    for (let i = 0; i < s1.length; i++) {
+        const currentRow = [i + 1];
+        for (let j = 0; j < s2.length; j++) {
+            const insertions = previousRow[j + 1] + 1;
+            const deletions = currentRow[j] + 1;
+            const substitutions = previousRow[j] + (s1[i] !== s2[j] ? 1 : 0);
+            currentRow.push(Math.min(insertions, deletions, substitutions));
+        }
+        previousRow = currentRow;
+    }
+    return previousRow[previousRow.length - 1];
+}
+export function fuzzyMatchScore(query, text, threshold = 0.7) {
+    if (!query || !text)
+        return 0.0;
+    const queryLower = query.toLowerCase();
+    const textLower = text.toLowerCase();
+    if (queryLower === textLower)
+        return 1.0;
+    if (textLower.includes(queryLower))
+        return 0.9;
+    const maxLen = Math.max(queryLower.length, textLower.length);
+    if (maxLen === 0)
+        return 0.0;
+    const distance = levenshteinDistance(queryLower, textLower);
+    const similarity = 1 - distance / maxLen;
+    return similarity >= threshold ? similarity : 0.0;
+}
+export function findFuzzyMatches(keyword, text, threshold = 0.7, maxWordLenDiff = 3) {
+    if (!keyword || !text)
+        return [];
+    const matches = [];
+    const keywordLower = keyword.toLowerCase();
+    const keywordLen = keywordLower.length;
+    const words = text.match(/[A-Za-z0-9_]+|[\u4e00-\u9fff]+/g) ?? [];
+    for (const word of words) {
+        const wordLower = word.toLowerCase();
+        const wordLen = wordLower.length;
+        if (Math.abs(wordLen - keywordLen) > maxWordLenDiff)
+            continue;
+        const score = fuzzyMatchScore(keywordLower, wordLower, threshold);
+        if (score > 0) {
+            matches.push([word, score]);
+        }
+    }
+    return matches.sort((a, b) => b[1] - a[1]);
+}
+// =============================================================================
+// Smart Cube Detection
+// =============================================================================
+export function detectCubeFromPath(projectPath) {
+    const targetPath = projectPath ?? process.cwd();
+    // Normalize: handle Windows backslashes
+    const normalized = targetPath.replace(/\\/g, "/");
+    // Extract folder name (last segment)
+    const segments = normalized.replace(/\/$/, "").split("/");
+    let folderName = segments[segments.length - 1] ?? "";
+    // Windows drive handling: "G:" → empty, take next
+    if (/^[A-Za-z]:$/.test(folderName)) {
+        folderName = segments[segments.length - 2] ?? "default";
+    }
+    if (!folderName)
+        return "default_cube";
+    // Normalize: lowercase, replace -, ., space with _
+    let cubeId = folderName.toLowerCase();
+    cubeId = cubeId.replace(/[-.\s]+/g, "_");
+    cubeId = cubeId.replace(/[^a-z0-9_]/g, "");
+    // Ensure doesn't start with digit
+    if (cubeId && /^\d/.test(cubeId)) {
+        cubeId = "_" + cubeId;
+    }
+    if (!cubeId.endsWith("_cube")) {
+        cubeId = cubeId + "_cube";
+    }
+    return cubeId || "default_cube";
+}
+// =============================================================================
+// Enhanced Keyword Extraction and Scoring
+// =============================================================================
+export function extractKeywordsEnhanced(query, stopwords = ALL_STOPWORDS, minLength = 2) {
+    if (!query)
+        return [];
+    const rawTokens = query.match(/[A-Za-z0-9_]+|[\u4e00-\u9fff]+/g) ?? [];
+    const keywords = [];
+    const seen = new Set();
+    for (const token of rawTokens) {
+        if (!token)
+            continue;
+        // Chinese token
+        if (/[\u4e00-\u9fff]/.test(token)) {
+            if (token.length < minLength)
+                continue;
+            if (stopwords.has(token))
+                continue;
+            if (!seen.has(token)) {
+                keywords.push(token);
+                seen.add(token);
+            }
+            continue;
+        }
+        // English token
+        const lowered = token.toLowerCase();
+        if (lowered.length < minLength)
+            continue;
+        if (stopwords.has(lowered))
+            continue;
+        if (!seen.has(lowered)) {
+            keywords.push(lowered);
+            seen.add(lowered);
+        }
+    }
+    return keywords;
+}
+export function keywordMatchScoreEnhanced(text, keywords, metadata, enableFuzzy = true, fuzzyThreshold = 0.75) {
+    if (!text || keywords.length === 0)
+        return 0.0;
+    const textLower = text.toLowerCase();
+    let score = 0.0;
+    let matchedCount = 0;
+    const keyField = metadata ? String(metadata.key ?? "").toLowerCase() : "";
+    const rawTags = metadata?.tags;
+    const tags = Array.isArray(rawTags)
+        ? rawTags.map((t) => String(t).toLowerCase())
+        : [];
+    for (const kw of keywords) {
+        const kwLower = kw.toLowerCase();
+        const isChinese = /[\u4e00-\u9fff]/.test(kw);
+        let kwMatched = false;
+        // 1. Key field match (highest weight)
+        if (keyField && (keyField.includes(kwLower) || (isChinese && keyField.includes(kw)))) {
+            score += 5.0;
+            kwMatched = true;
+        }
+        // 2. Tags match
+        for (const tag of tags) {
+            if (tag.includes(kwLower) || (isChinese && tag.includes(kw))) {
+                score += 3.0;
+                kwMatched = true;
+                break;
+            }
+        }
+        // 3. Text match
+        if (isChinese) {
+            if (text.includes(kw)) {
+                score += 2.0;
+                kwMatched = true;
+            }
+        }
+        else {
+            const wordBoundaryRegex = new RegExp(`\\b${escapeRegex(kwLower)}\\b`);
+            if (wordBoundaryRegex.test(textLower)) {
+                score += 2.5;
+                kwMatched = true;
+            }
+            else if (textLower.includes(kwLower)) {
+                score += 1.5;
+                kwMatched = true;
+            }
+        }
+        // 4. Fuzzy match
+        if (enableFuzzy && !kwMatched && !isChinese) {
+            const fuzzyMatches = findFuzzyMatches(kwLower, textLower, fuzzyThreshold);
+            if (fuzzyMatches.length > 0) {
+                score += fuzzyMatches[0][1] * 1.0;
+                kwMatched = true;
+            }
+        }
+        if (kwMatched)
+            matchedCount++;
+    }
+    // Coverage bonus
+    if (matchedCount > 0) {
+        const coverage = matchedCount / keywords.length;
+        score += coverage * 1.5;
+    }
+    return score;
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=keyword-enhancer.js.map

package/dist/memory-analysis.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Memory Analysis Module
+ *
+ * Generates search suggestions based on context.
+ */
+export declare function suggestSearchQueries(context: string): string[];
+//# sourceMappingURL=memory-analysis.d.ts.map

package/dist/memory-analysis.js

@@ -0,0 +1,45 @@
+/**
+ * Memory Analysis Module
+ *
+ * Generates search suggestions based on context.
+ */
+import { extractKeywords } from "./query-processing.js";
+const MEMORY_TYPE_KEYWORDS = {
+    ERROR_PATTERN: ["error", "bug", "exception", "fail", "crash", "traceback", "错误", "异常", "失败"],
+    DECISION: ["decision", "decided", "choose", "选择", "决定", "方案", "架构"],
+    BUGFIX: ["fix", "fixed", "patch", "repair", "修复", "解决"],
+    GOTCHA: ["gotcha", "trap", "caveat", "workaround", "注意", "陷阱", "坑"],
+    CODE_PATTERN: ["pattern", "template", "snippet", "example", "模板", "示例"],
+    CONFIG: ["config", "configuration", "setting", "env", "配置", "环境"],
+    MILESTONE: ["milestone", "completed", "released", "shipped", "完成", "里程碑"],
+    FEATURE: ["feature", "added", "implemented", "new", "新功能", "实现"],
+};
+export function suggestSearchQueries(context) {
+    if (!context)
+        return [];
+    const suggestions = [];
+    const contextLower = context.toLowerCase();
+    // Check for memory type keywords
+    for (const [memType, keywords] of Object.entries(MEMORY_TYPE_KEYWORDS)) {
+        if (keywords.some((kw) => contextLower.includes(kw))) {
+            const extracted = extractKeywords(context);
+            if (extracted.length > 0) {
+                suggestions.push(`${memType} ${extracted.slice(0, 2).join(" ")}`);
+            }
+            else {
+                suggestions.push(memType);
+            }
+        }
+    }
+    // Add generic keyword-based suggestions
+    const keywords = extractKeywords(context).slice(0, 3);
+    if (keywords.length > 0 && suggestions.length === 0) {
+        suggestions.push(keywords.join(" "));
+        if (keywords.length > 1) {
+            suggestions.push(keywords[0]);
+        }
+    }
+    // Remove duplicates and limit to 5
+    return [...new Set(suggestions)].slice(0, 5);
+}
+//# sourceMappingURL=memory-analysis.js.map

package/dist/models.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Layered Memory Models + Compaction Logic
+ */
+import type { MemoryNode, MemoryMinimal, MemoryBrief, MemoryFull } from "./types.js";
+export declare const COMPACTION_THRESHOLD = 15;
+export declare const PREVIEW_COUNT = 5;
+export declare function shouldCompact(count: number): boolean;
+export declare function getTypeIcon(memoryType: string): string;
+export declare function toMinimal(memory: MemoryNode | Record<string, unknown>): MemoryMinimal;
+export declare function toBrief(memory: MemoryNode | Record<string, unknown>): MemoryBrief;
+export declare function toFull(memory: MemoryNode | Record<string, unknown>, cubeId?: string, userId?: string): MemoryFull;
+export interface CompactedSearchResultData {
+    preview: MemoryMinimal[];
+    totalCount: number;
+    omittedCount: number;
+    message: string;
+    query: string;
+    cubeId: string;
+}
+export declare function compactedResultToText(result: CompactedSearchResultData): string;
+//# sourceMappingURL=models.d.ts.map

package/dist/models.js

@@ -0,0 +1,101 @@
+/**
+ * Layered Memory Models + Compaction Logic
+ */
+import { extractMcpType } from "./query-processing.js";
+// ============================================================================
+// Compaction Configuration
+// ============================================================================
+export const COMPACTION_THRESHOLD = 15;
+export const PREVIEW_COUNT = 5;
+export function shouldCompact(count) {
+    return count > COMPACTION_THRESHOLD;
+}
+// ============================================================================
+// Type Icon
+// ============================================================================
+export function getTypeIcon(memoryType) {
+    const icons = {
+        ERROR_PATTERN: "🔴",
+        BUGFIX: "🐛",
+        DECISION: "📋",
+        GOTCHA: "⚠️",
+        CODE_PATTERN: "📝",
+        CONFIG: "⚙️",
+        FEATURE: "✨",
+        MILESTONE: "🎯",
+        PROGRESS: "📊",
+        INFERRED: "🔗",
+    };
+    return icons[memoryType] ?? "📌";
+}
+// ============================================================================
+// Conversion Utilities
+// ============================================================================
+export function toMinimal(memory) {
+    const memoryType = extractMcpType(memory);
+    const content = memory.memory ?? memory.content ?? "";
+    const cleanContent = content.replace(/^\[[A-Z_]+\]\s*/, "");
+    const lines = cleanContent.split("\n").filter((l) => l.trim());
+    const firstLine = lines[0] ?? cleanContent;
+    const summary = firstLine.length > 100 ? firstLine.slice(0, 100) + "..." : firstLine;
+    const meta = memory.metadata ?? {};
+    const created = memory.updated_at ??
+        memory.created_at ??
+        meta.updated_at ??
+        meta.created_at;
+    return {
+        id: memory.id ?? "",
+        memoryType,
+        summary,
+        createdAt: created,
+    };
+}
+export function toBrief(memory) {
+    const minimal = toMinimal(memory);
+    const meta = memory.metadata ?? {};
+    const rawTags = memory.tags ?? meta.tags ?? [];
+    return {
+        ...minimal,
+        key: memory.key ?? meta.key,
+        tags: Array.isArray(rawTags) ? rawTags.map(String) : [],
+        relevance: meta.relativity ?? 1.0,
+    };
+}
+export function toFull(memory, cubeId = "", userId = "") {
+    const brief = toBrief(memory);
+    const meta = memory.metadata ?? {};
+    const content = memory.memory ?? memory.content ?? "";
+    const cleanContent = content.replace(/^\[[A-Z_]+\]\s*/, "");
+    return {
+        ...brief,
+        content: cleanContent,
+        background: memory.background ?? meta.background,
+        cubeId,
+        userId,
+        relations: memory.relations ?? [],
+    };
+}
+export function compactedResultToText(result) {
+    const lines = [
+        "## 🔍 Search Results (Compacted)",
+        "",
+        `**Query**: \`${result.query}\``,
+        `**Total**: ${result.totalCount} memories found`,
+        `**Showing**: Top ${result.preview.length} (omitted ${result.omittedCount})`,
+        "",
+        "### Preview",
+        "",
+    ];
+    for (let i = 0; i < result.preview.length; i++) {
+        const mem = result.preview[i];
+        const icon = getTypeIcon(mem.memoryType);
+        lines.push(`${i + 1}. ${icon} **[${mem.memoryType}]** ${mem.summary}`);
+        lines.push(`   ID: \`${mem.id}\``);
+        lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push('💡 **Tip**: Use `memos_get(memory_id="<id>")` to get full details of a specific memory.');
+    return lines.join("\n");
+}
+//# sourceMappingURL=models.js.map