oh-memos-mcp 1.0.0

package/dist/cube-manager.js

@@ -0,0 +1,357 @@
+/**
+ * MemOS MCP Server Cube Management Module
+ *
+ * Handles cube discovery, config, and registration.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { MEMOS_URL, MEMOS_USER, MEMOS_DEFAULT_CUBE, MEMOS_CUBES_DIR, MEMOS_TIMEOUT_STARTUP, REGISTRATION_RETRY_INTERVAL, registeredCubes, lastRegistrationAttempt, logger, isDefaultCubeFromEnv, } from "./config.js";
+import { detectCubeFromPath } from "./keyword-enhancer.js";
+import { fetchWithTimeout } from "./api-client.js";
+// ============================================================================
+// Windows/WSL Path Conversion
+// ============================================================================
+/**
+ * Convert Windows path to WSL/Linux path for local file access.
+ * e.g. "G:\\test\\MemOS\\data" → "/mnt/g/test/MemOS/data"
+ */
+function toLocalPath(p) {
+    // Already a Unix path
+    if (p.startsWith("/"))
+        return p;
+    // Windows absolute path: "G:\..." or "G:/..."
+    const winMatch = p.match(/^([A-Za-z]):[/\\](.*)/);
+    if (winMatch) {
+        const drive = winMatch[1].toLowerCase();
+        const rest = winMatch[2].replace(/\\/g, "/");
+        return `/mnt/${drive}/${rest}`;
+    }
+    return p;
+}
+// ============================================================================
+// Cube Discovery
+// ============================================================================
+export function getCubesBaseDir() {
+    const cubesDir = MEMOS_CUBES_DIR;
+    if (cubesDir.endsWith(MEMOS_DEFAULT_CUBE)) {
+        return path.dirname(cubesDir);
+    }
+    return cubesDir;
+}
+export function getLocalCubesBaseDir() {
+    return toLocalPath(getCubesBaseDir());
+}
+export function listAvailableCubes() {
+    const available = [];
+    const cubesDirLocal = getLocalCubesBaseDir();
+    if (!fs.existsSync(cubesDirLocal) || !fs.statSync(cubesDirLocal).isDirectory()) {
+        logger.warning(`Cubes directory does not exist: ${cubesDirLocal}`);
+        return available;
+    }
+    try {
+        const items = fs.readdirSync(cubesDirLocal);
+        for (const item of items) {
+            const itemPath = path.join(cubesDirLocal, item);
+            const configPath = path.join(itemPath, "config.json");
+            if (fs.existsSync(itemPath) &&
+                fs.statSync(itemPath).isDirectory() &&
+                fs.existsSync(configPath)) {
+                available.push({ id: item, path: itemPath });
+            }
+        }
+    }
+    catch (err) {
+        logger.warning(`Error scanning cubes directory: ${err}`);
+    }
+    return available;
+}
+export function getCubePath(cubeId) {
+    const localBase = getLocalCubesBaseDir();
+    let cubePath;
+    if (cubeId === MEMOS_DEFAULT_CUBE) {
+        const cubesDirLocal = toLocalPath(MEMOS_CUBES_DIR);
+        if (cubesDirLocal.endsWith(MEMOS_DEFAULT_CUBE)) {
+            cubePath = cubesDirLocal;
+        }
+        else {
+            cubePath = path.join(cubesDirLocal, MEMOS_DEFAULT_CUBE);
+        }
+    }
+    else {
+        cubePath = path.join(localBase, cubeId);
+    }
+    const configPath = path.join(cubePath, "config.json");
+    if (fs.existsSync(cubePath) && fs.statSync(cubePath).isDirectory() && fs.existsSync(configPath)) {
+        return cubePath;
+    }
+    return null;
+}
+/**
+ * Get the original (possibly Windows) path for the cube, for API registration.
+ * The API runs on Windows, so it needs the Windows path.
+ */
+function getCubeApiPath(cubeId) {
+    const localPath = getCubePath(cubeId);
+    if (!localPath)
+        return null;
+    // Convert back to Windows path if MEMOS_CUBES_DIR is a Windows path
+    const cubesDir = MEMOS_CUBES_DIR;
+    const isWindowsPath = /^[A-Za-z]:/.test(cubesDir);
+    if (isWindowsPath) {
+        // Local path is /mnt/g/... → G:\...
+        const match = localPath.match(/^\/mnt\/([a-z])\/(.*)/);
+        if (match) {
+            const drive = match[1].toUpperCase();
+            const rest = match[2].replace(/\//g, "\\");
+            return `${drive}:\\${rest}`;
+        }
+    }
+    return localPath;
+}
+// ============================================================================
+// Cube Configuration
+// ============================================================================
+function cloneConfig(config) {
+    return JSON.parse(JSON.stringify(config));
+}
+function updateConfigForCube(config, cubeId) {
+    config.user_id = MEMOS_USER;
+    config.cube_id = cubeId;
+    config.config_filename = "config.json";
+    const textMem = config.text_mem;
+    if (typeof textMem === "object" && textMem !== null) {
+        const textCfg = textMem.config;
+        if (typeof textCfg === "object" && textCfg !== null) {
+            const tc = textCfg;
+            if ("cube_id" in tc)
+                tc.cube_id = cubeId;
+            const graphDb = tc.graph_db;
+            if (typeof graphDb === "object" && graphDb !== null) {
+                const graphCfg = graphDb.config;
+                if (typeof graphCfg === "object" && graphCfg !== null) {
+                    const gc = graphCfg;
+                    const useMultiDb = gc.use_multi_db;
+                    if (useMultiDb === false || "user_name" in gc) {
+                        gc.user_name = cubeId;
+                    }
+                    const vecCfg = typeof gc.vec_config === "object" && gc.vec_config !== null
+                        ? gc.vec_config.config
+                        : null;
+                    if (vecCfg && typeof vecCfg === "object" && "collection_name" in vecCfg) {
+                        vecCfg.collection_name = `${cubeId}_graph`;
+                    }
+                }
+            }
+            const vectorDb = tc.vector_db;
+            if (typeof vectorDb === "object" && vectorDb !== null) {
+                const vectorCfg = vectorDb.config;
+                if (typeof vectorCfg === "object" && vectorCfg !== null && "collection_name" in vectorCfg) {
+                    vectorCfg.collection_name = `${cubeId}_collection`;
+                }
+            }
+        }
+    }
+    return config;
+}
+function buildCubeConfig(cubeId) {
+    const templatePath = getCubePath(MEMOS_DEFAULT_CUBE);
+    if (templatePath !== null) {
+        const configPath = path.join(templatePath, "config.json");
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            const cloned = cloneConfig(config);
+            return updateConfigForCube(cloned, cubeId);
+        }
+        catch (err) {
+            logger.warning(`Failed to read template cube config: ${err}`);
+        }
+    }
+    // Minimal fallback config (will likely fail API registration without proper fields)
+    return {
+        user_id: MEMOS_USER,
+        cube_id: cubeId,
+        config_filename: "config.json",
+        text_mem: {},
+        act_mem: {},
+        para_mem: {},
+    };
+}
+export function validateAndFixCubeConfig(cubeId, configPath) {
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        let modified = false;
+        if (config.cube_id !== cubeId) {
+            config.cube_id = cubeId;
+            modified = true;
+        }
+        const textMem = config.text_mem;
+        if (typeof textMem === "object" && textMem !== null) {
+            const textCfg = textMem.config;
+            if (typeof textCfg === "object" && textCfg !== null) {
+                const tc = textCfg;
+                if (tc.cube_id !== cubeId) {
+                    tc.cube_id = cubeId;
+                    modified = true;
+                }
+                const graphDb = tc.graph_db;
+                if (typeof graphDb === "object" && graphDb !== null) {
+                    const graphCfg = graphDb.config;
+                    if (typeof graphCfg === "object" && graphCfg !== null) {
+                        const gc = graphCfg;
+                        if (gc.user_name && gc.user_name !== cubeId) {
+                            gc.user_name = cubeId;
+                            modified = true;
+                        }
+                        const vecCfg = typeof gc.vec_config === "object" && gc.vec_config !== null
+                            ? gc.vec_config.config
+                            : null;
+                        if (vecCfg && typeof vecCfg === "object" && "collection_name" in vecCfg) {
+                            const expected = `${cubeId}_graph`;
+                            if (vecCfg.collection_name !== expected) {
+                                vecCfg.collection_name = expected;
+                                modified = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (modified) {
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        }
+        return [modified, null];
+    }
+    catch (err) {
+        return [false, `Failed to validate cube config: ${err}`];
+    }
+}
+export function ensureCubeDirectory(cubeId) {
+    const localBase = getLocalCubesBaseDir();
+    try {
+        fs.mkdirSync(localBase, { recursive: true });
+        const cubeDir = path.join(localBase, cubeId);
+        const configPath = path.join(cubeDir, "config.json");
+        if (fs.existsSync(cubeDir) && fs.existsSync(configPath)) {
+            validateAndFixCubeConfig(cubeId, configPath);
+            return [cubeDir, null];
+        }
+        fs.mkdirSync(cubeDir, { recursive: true });
+        const config = buildCubeConfig(cubeId);
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        return [cubeDir, null];
+    }
+    catch (err) {
+        return [null, `Failed to create cube '${cubeId}': ${err}`];
+    }
+}
+// ============================================================================
+// Cube Registration
+// ============================================================================
+export async function verifyCubeLoaded(cubeId) {
+    try {
+        const response = await fetchWithTimeout(`${MEMOS_URL}/memories?user_id=${encodeURIComponent(MEMOS_USER)}&mem_cube_id=${encodeURIComponent(cubeId)}`, { method: "GET", timeoutMs: 5 });
+        if (response.ok) {
+            const data = await response.json();
+            return data.code === 200;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return false;
+}
+export async function ensureCubeRegistered(cubeId, force = false) {
+    const now = Date.now() / 1000;
+    if (!force && registeredCubes.has(cubeId))
+        return [true, null];
+    if (!force) {
+        const lastAttempt = lastRegistrationAttempt.get(cubeId) ?? 0;
+        if (now - lastAttempt < REGISTRATION_RETRY_INTERVAL && registeredCubes.has(cubeId)) {
+            return [true, null];
+        }
+    }
+    lastRegistrationAttempt.set(cubeId, now);
+    try {
+        // Check if already loaded
+        if (await verifyCubeLoaded(cubeId)) {
+            registeredCubes.add(cubeId);
+            logger.debug(`Cube '${cubeId}' already loaded`);
+            return [true, null];
+        }
+        // Get or create cube path
+        let cubePath = getCubeApiPath(cubeId);
+        if (!cubePath) {
+            // Try to auto-create
+            logger.debug(`Cube '${cubeId}' not found, attempting auto-creation...`);
+            const templatePath = getCubePath(MEMOS_DEFAULT_CUBE);
+            if (!templatePath) {
+                const available = listAvailableCubes();
+                const availableIds = available.map((c) => c.id);
+                if (availableIds.length > 0) {
+                    return [false, `Cube '${cubeId}' not found. Available cubes: ${availableIds.join(", ")}`];
+                }
+                return [false, `Cube '${cubeId}' not found and no cubes available.`];
+            }
+            const [newDir, createErr] = ensureCubeDirectory(cubeId);
+            if (!newDir) {
+                return [false, `Failed to auto-create cube '${cubeId}': ${createErr}`];
+            }
+            cubePath = getCubeApiPath(cubeId);
+            if (!cubePath) {
+                return [false, `Failed to get path for cube '${cubeId}' after creation`];
+            }
+        }
+        // Register with API
+        const response = await fetchWithTimeout(`${MEMOS_URL}/mem_cubes`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                user_id: MEMOS_USER,
+                mem_cube_name_or_path: cubePath,
+                mem_cube_id: cubeId,
+            }),
+            timeoutMs: MEMOS_TIMEOUT_STARTUP,
+        });
+        if (response.ok) {
+            const data = await response.json();
+            if (data.code === 200) {
+                registeredCubes.add(cubeId);
+                logger.debug(`Auto-registered cube: ${cubeId}`);
+                return [true, null];
+            }
+            const msg = String(data.message ?? "Unknown error");
+            if (msg.toLowerCase().includes("already")) {
+                registeredCubes.add(cubeId);
+                return [true, null];
+            }
+            const available = listAvailableCubes();
+            const availableIds = available.map((c) => c.id);
+            return [false, `Failed to register cube '${cubeId}': ${msg}. Available: ${availableIds.join(", ") || "none"}`];
+        }
+    }
+    catch (err) {
+        const msg = String(err);
+        if (msg.includes("ECONNREFUSED") || msg.includes("fetch failed") || msg.includes("ECONNRESET")) {
+            return [false, `Cannot connect to MemOS API at ${MEMOS_URL}. Is the server running?`];
+        }
+        return [false, `Failed to register cube '${cubeId}': ${err}`];
+    }
+    return [false, `Unknown error registering cube '${cubeId}'`];
+}
+// ============================================================================
+// Default Cube ID
+// ============================================================================
+export function getDefaultCubeId() {
+    if (isDefaultCubeFromEnv()) {
+        if (getCubePath(MEMOS_DEFAULT_CUBE) !== null) {
+            return MEMOS_DEFAULT_CUBE;
+        }
+    }
+    try {
+        return detectCubeFromPath(process.cwd());
+    }
+    catch {
+        return MEMOS_DEFAULT_CUBE;
+    }
+}
+//# sourceMappingURL=cube-manager.js.map

package/dist/formatters.d.ts

@@ -0,0 +1,16 @@
+/**
+ * MemOS MCP Server Formatters
+ *
+ * Formats memory search results and knowledge graphs for display.
+ */
+import type { SearchData, MemoryNode, GraphEdge } from "./types.js";
+export declare function formatMemoriesForDisplay(data: SearchData): string;
+export interface GraphCubeData {
+    cube_id?: string;
+    memories?: Array<{
+        nodes?: MemoryNode[];
+        edges?: GraphEdge[];
+    }>;
+}
+export declare function formatGraphForDisplay(data: GraphCubeData[]): string;
+//# sourceMappingURL=formatters.d.ts.map

package/dist/formatters.js

@@ -0,0 +1,174 @@
+/**
+ * MemOS MCP Server Formatters
+ *
+ * Formats memory search results and knowledge graphs for display.
+ */
+// ============================================================================
+// Memory Display Formatter
+// ============================================================================
+export function formatMemoriesForDisplay(data) {
+    const results = [];
+    const textMems = data.text_mem ?? [];
+    for (const cubeData of textMems) {
+        const cubeId = cubeData.cube_id ?? "unknown";
+        const memoriesData = cubeData.memories;
+        let memories = [];
+        if (memoriesData && !Array.isArray(memoriesData) && memoriesData.nodes) {
+            memories = memoriesData.nodes;
+        }
+        else if (Array.isArray(memoriesData)) {
+            memories = memoriesData;
+        }
+        if (memories.length === 0)
+            continue;
+        results.push(`## 📦 Cube: ${cubeId}`);
+        results.push("");
+        // Group by type
+        const grouped = {};
+        for (const mem of memories) {
+            const memText = mem.memory ?? "";
+            const typeMatch = memText.match(/^\[([A-Z_]+)\]/);
+            const memType = typeMatch ? typeMatch[1] : "PROGRESS";
+            if (!grouped[memType])
+                grouped[memType] = [];
+            grouped[memType].push(mem);
+        }
+        // Display by type
+        for (const [memType, items] of Object.entries(grouped)) {
+            results.push(`### 🏷️ Type: ${memType}`);
+            results.push("");
+            for (let i = 0; i < items.length; i++) {
+                const mem = items[i];
+                const memText = mem.memory ?? "";
+                const memId = mem.id ?? "";
+                // Remove [TYPE] prefix
+                const displayText = memText.replace(/^\[[A-Z_]+\]\s*/, "");
+                const firstLine = displayText.split("\n")[0].slice(0, 100);
+                if (displayText.split("\n").length > 1 || displayText.length > 100) {
+                    results.push(`#### ${i + 1}. ${firstLine}`);
+                }
+                else {
+                    results.push(`#### ${i + 1}. ${displayText}`);
+                }
+                results.push(`ID: \`${memId}\``);
+                results.push("");
+                // Detect code blocks
+                const hasCodeIndicator = displayText.split("\n").some((line) => /^(import |def |class |export |const |let |var )/.test(line.trim()));
+                if (!displayText.includes("```") && hasCodeIndicator) {
+                    results.push("```python");
+                    results.push(displayText);
+                    results.push("```");
+                }
+                else {
+                    results.push(displayText);
+                }
+                results.push("");
+                results.push("---");
+                results.push("");
+            }
+        }
+    }
+    if (results.length === 0) {
+        return "No memories found matching your query.";
+    }
+    return results.join("\n");
+}
+export function formatGraphForDisplay(data) {
+    const results = [];
+    for (const cubeData of data) {
+        const cubeId = cubeData.cube_id ?? "unknown";
+        const memoriesList = cubeData.memories ?? [];
+        if (memoriesList.length === 0)
+            continue;
+        results.push(`## 🧠 Knowledge Graph: ${cubeId}`);
+        results.push("");
+        for (const memData of memoriesList) {
+            const nodes = memData.nodes ?? [];
+            const edges = memData.edges ?? [];
+            // Build node lookup
+            const nodeLookup = {};
+            for (const node of nodes) {
+                const nodeId = node.id ?? "";
+                const nodeMemory = node.memory ?? "";
+                const cleanText = nodeMemory.replace(/\n/g, " ").replace(/"/g, "'").replace(/\[/g, "(").replace(/\]/g, ")");
+                nodeLookup[nodeId] = cleanText.length > 50 ? cleanText.slice(0, 50) + "..." : cleanText;
+            }
+            // Display nodes
+            if (nodes.length > 0) {
+                results.push("### 📝 Memory Nodes");
+                results.push("");
+                for (let i = 0; i < Math.min(nodes.length, 10); i++) {
+                    const node = nodes[i];
+                    const memory = node.memory ?? "";
+                    const firstLine = memory.split("\n")[0].slice(0, 100);
+                    const nodeId = node.id ?? "";
+                    results.push(`${i + 1}. **${firstLine}**`);
+                    results.push(`   ID: \`${nodeId}\``);
+                    results.push("");
+                }
+            }
+            // Display relationships with Mermaid
+            if (edges.length > 0) {
+                results.push("### 📊 Relationship Diagram (Mermaid)");
+                results.push("");
+                results.push("```mermaid");
+                results.push("graph TD");
+                results.push("    classDef cause fill:#f96,stroke:#333,stroke-width:2px;");
+                results.push("    classDef relate fill:#bbf,stroke:#333,stroke-width:1px;");
+                results.push("    classDef conflict fill:#f66,stroke:#333,stroke-width:2px,stroke-dasharray: 5 5;");
+                const addedEdges = new Set();
+                for (const edge of edges) {
+                    const sourceId = edge.source ?? "";
+                    const targetId = edge.target ?? "";
+                    const relType = edge.type ?? "UNKNOWN";
+                    if (relType === "PARENT")
+                        continue;
+                    const edgeKey = `${sourceId}-${targetId}-${relType}`;
+                    if (addedEdges.has(edgeKey))
+                        continue;
+                    addedEdges.add(edgeKey);
+                    const sourceText = nodeLookup[sourceId] ?? sourceId.slice(0, 8);
+                    const targetText = nodeLookup[targetId] ?? targetId.slice(0, 8);
+                    const sId = `node_${sourceId.slice(0, 8)}`;
+                    const tId = `node_${targetId.slice(0, 8)}`;
+                    if (relType === "CAUSE") {
+                        results.push(`    ${sId}["${sourceText}"] -- CAUSE --> ${tId}["${targetText}"]:::cause`);
+                    }
+                    else if (relType === "RELATE") {
+                        results.push(`    ${sId}["${sourceText}"] -. RELATE .- ${tId}["${targetText}"]:::relate`);
+                    }
+                    else if (relType === "CONFLICT") {
+                        results.push(`    ${sId}["${sourceText}"] == CONFLICT == ${tId}["${targetText}"]:::conflict`);
+                    }
+                    else if (relType === "CONDITION") {
+                        results.push(`    ${sId}["${sourceText}"] -- CONDITION --> ${tId}["${targetText}"]`);
+                    }
+                    else {
+                        results.push(`    ${sId}["${sourceText}"] -- ${relType} --> ${tId}["${targetText}"]`);
+                    }
+                }
+                results.push("```");
+                results.push("");
+                // Textual fallback
+                results.push("### 🔗 Textual Relationships");
+                results.push("");
+                results.push("```");
+                for (const edge of edges) {
+                    if (edge.type === "PARENT")
+                        continue;
+                    const sText = (nodeLookup[edge.source ?? ""] ?? "???").slice(0, 40);
+                    const tText = (nodeLookup[edge.target ?? ""] ?? "???").slice(0, 40);
+                    results.push(`[${sText}] --${edge.type}--> [${tText}]`);
+                }
+                results.push("```");
+                results.push("");
+            }
+        }
+        results.push("---");
+    }
+    if (results.length === 0) {
+        return "No memories or relationships found.";
+    }
+    return results.join("\n");
+}
+//# sourceMappingURL=formatters.js.map

package/dist/handlers/admin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Admin Handlers
+ *
+ * memos_list_cubes, memos_register_cube, memos_create_user,
+ * memos_validate_cubes, memos_delete
+ */
+import type { TextContent } from "../types.js";
+export declare function handleMemosListCubes(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosRegisterCube(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosCreateUser(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosValidateCubes(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosDelete(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+//# sourceMappingURL=admin.d.ts.map