oh-memos-mcp 1.0.0

package/dist/handlers/admin.js

@@ -0,0 +1,331 @@
+/**
+ * Admin Handlers
+ *
+ * memos_list_cubes, memos_register_cube, memos_create_user,
+ * memos_validate_cubes, memos_delete
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { MEMOS_URL, MEMOS_USER, MEMOS_DEFAULT_CUBE, MEMOS_CUBES_DIR, MEMOS_ENABLE_DELETE, MEMOS_TIMEOUT_TOOL, registeredCubes, } from "../config.js";
+import { fetchWithTimeout } from "../api-client.js";
+import { ensureCubeRegistered, getCubePath, getCubesBaseDir, getLocalCubesBaseDir, listAvailableCubes, validateAndFixCubeConfig, verifyCubeLoaded, } from "../cube-manager.js";
+import { ERR_CUBE_NOT_FOUND, ERR_DELETE_DISABLED, ERR_PARAM_MISSING, apiErrorResponse, cubeRegistrationError, errorResponse, getCubeIdFromArgs, } from "./utils.js";
+// ============================================================================
+// memos_list_cubes
+// ============================================================================
+export async function handleMemosListCubes(arguments_) {
+    const includeStatus = arguments_.include_status === true;
+    const available = listAvailableCubes();
+    if (available.length === 0) {
+        const cubesDir = MEMOS_CUBES_DIR.endsWith(MEMOS_DEFAULT_CUBE)
+            ? path.dirname(MEMOS_CUBES_DIR)
+            : MEMOS_CUBES_DIR;
+        return [{ type: "text", text: [
+                    "## No cubes found",
+                    "",
+                    `Cubes directory: \`${cubesDir}\``,
+                    "",
+                    `To create a new cube, use the MemOS web interface at ${MEMOS_URL}/docs`,
+                    "or create a cube directory with a config.json file.",
+                ].join("\n") }];
+    }
+    const result = ["## Available Memory Cubes\n"];
+    result.push(`Cubes directory: \`${MEMOS_CUBES_DIR}\`\n`);
+    for (const cube of available) {
+        if (includeStatus) {
+            const isLoaded = await verifyCubeLoaded(cube.id);
+            const status = isLoaded ? "loaded" : "not loaded";
+            result.push(`- **${cube.id}**: \`${cube.path}\` (${status})`);
+        }
+        else {
+            result.push(`- **${cube.id}**: \`${cube.path}\``);
+        }
+    }
+    result.push(`\n**Default cube**: \`${MEMOS_DEFAULT_CUBE}\``);
+    result.push("\n*Use `memos_list_cubes(include_status=True)` to check registration status.*");
+    return [{ type: "text", text: result.join("\n") }];
+}
+// ============================================================================
+// memos_register_cube
+// ============================================================================
+export async function handleMemosRegisterCube(arguments_) {
+    const cubeId = String(arguments_.cube_id ?? "");
+    let cubePath = arguments_.cube_path ? String(arguments_.cube_path) : undefined;
+    if (!cubeId) {
+        return errorResponse("cube_id parameter is required", ERR_PARAM_MISSING, [
+            "Use memos_list_cubes() to find available cubes",
+            '`memos_register_cube(cube_id="dev_cube")`',
+        ]);
+    }
+    if (!cubePath) {
+        // Try to find cube path (returns Windows/original path for API)
+        const localPath = getCubePath(cubeId);
+        if (!localPath) {
+            const available = listAvailableCubes();
+            const hint = available.length > 0
+                ? `\n\n**Available cubes:**\n${available.map((c) => `- \`${c.id}\``).join("\n")}`
+                : "";
+            return [{ type: "text", text: `❌ Cube \`${cubeId}\` not found in cubes directory.\n\nCubes directory: \`${getCubesBaseDir()}\`${hint}` }];
+        }
+        // Convert back to Windows path if needed
+        const cubesDir = MEMOS_CUBES_DIR;
+        const isWindowsPath = /^[A-Za-z]:/.test(cubesDir);
+        if (isWindowsPath) {
+            const match = localPath.match(/^\/mnt\/([a-z])\/(.*)/);
+            if (match) {
+                cubePath = `${match[1].toUpperCase()}:\\${match[2].replace(/\//g, "\\")}`;
+            }
+            else {
+                cubePath = localPath;
+            }
+        }
+        else {
+            cubePath = localPath;
+        }
+    }
+    try {
+        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_TOOL,
+        });
+        if (response.ok) {
+            const data = await response.json();
+            if (data.code === 200) {
+                registeredCubes.add(cubeId);
+                return [{ type: "text", text: [
+                            "✅ **Cube registered successfully!**",
+                            "",
+                            `- Cube ID: \`${cubeId}\``,
+                            `- Path: \`${cubePath}\``,
+                            "",
+                            "You can now use this cube with other memos_* tools.",
+                        ].join("\n") }];
+            }
+            else {
+                const errorMsg = String(data.message ?? "Unknown error");
+                let hint = "";
+                if (errorMsg.toLowerCase().includes("reranker")) {
+                    hint = "Edit the cube's config.json and change `reranker.backend` to `http_bge` or `noop`.";
+                }
+                else if (errorMsg.toLowerCase().includes("user")) {
+                    hint = "Use `memos_create_user` tool to create the user first.";
+                }
+                return errorResponse(`Registration failed: ${errorMsg}`, errorMsg.toLowerCase().includes("not found") ? ERR_CUBE_NOT_FOUND : undefined, hint ? [hint] : []);
+            }
+        }
+        else {
+            return apiErrorResponse("Registration", `HTTP ${response.status}`);
+        }
+    }
+    catch (err) {
+        return apiErrorResponse("Registration", String(err));
+    }
+}
+// ============================================================================
+// memos_create_user
+// ============================================================================
+export async function handleMemosCreateUser(arguments_) {
+    const userId = String(arguments_.user_id ?? MEMOS_USER);
+    const userName = String(arguments_.user_name ?? userId);
+    try {
+        const response = await fetchWithTimeout(`${MEMOS_URL}/users`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                user_name: userName,
+                user_id: userId,
+                role: "USER",
+            }),
+            timeoutMs: MEMOS_TIMEOUT_TOOL,
+        });
+        if (response.ok) {
+            const data = await response.json();
+            if (data.code === 200) {
+                return [{ type: "text", text: [
+                            "✅ **User created successfully!**",
+                            "",
+                            `- User ID: \`${userId}\``,
+                            `- User Name: \`${userName}\``,
+                            "",
+                            "You can now register cubes and store memories.",
+                        ].join("\n") }];
+            }
+            else {
+                const errorMsg = String(data.message ?? "Unknown error");
+                if (errorMsg.toLowerCase().includes("exist")) {
+                    return [{ type: "text", text: `ℹ️ User \`${userId}\` already exists. You can proceed with cube registration.` }];
+                }
+                return errorResponse(`User creation failed: ${errorMsg}`);
+            }
+        }
+        else {
+            return apiErrorResponse("User creation", `HTTP ${response.status}`);
+        }
+    }
+    catch (err) {
+        return apiErrorResponse("User creation", String(err));
+    }
+}
+// ============================================================================
+// memos_validate_cubes
+// ============================================================================
+export async function handleMemosValidateCubes(arguments_) {
+    const fixIssues = arguments_.fix !== false; // Default true
+    const localCubesDir = getLocalCubesBaseDir();
+    if (!fs.existsSync(localCubesDir) || !fs.statSync(localCubesDir).isDirectory()) {
+        return errorResponse(`Cubes directory not found: ${localCubesDir}`, ERR_CUBE_NOT_FOUND, [
+            "Set MEMOS_CUBES_DIR in .env",
+            "Verify the directory exists on disk",
+        ]);
+    }
+    const results = ["## 🔍 Cube Configuration Validation\n"];
+    let fixedCount = 0;
+    let errorCount = 0;
+    let okCount = 0;
+    try {
+        const items = fs.readdirSync(localCubesDir);
+        for (const cubeName of items) {
+            const cubePath = path.join(localCubesDir, cubeName);
+            const configPath = path.join(cubePath, "config.json");
+            if (!fs.existsSync(cubePath) || !fs.statSync(cubePath).isDirectory() || !fs.existsSync(configPath)) {
+                continue;
+            }
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                const issues = [];
+                if (config.cube_id !== cubeName) {
+                    issues.push(`cube_id: \`${config.cube_id}\` → \`${cubeName}\``);
+                }
+                const textCfg = config.text_mem?.config;
+                const graphCfg = textCfg?.graph_db?.config;
+                const currentUserName = graphCfg?.user_name;
+                if (currentUserName && currentUserName !== cubeName) {
+                    issues.push(`user_name: \`${currentUserName}\` → \`${cubeName}\``);
+                }
+                if (issues.length > 0) {
+                    if (fixIssues) {
+                        const [wasFixes, fixError] = validateAndFixCubeConfig(cubeName, configPath);
+                        if (wasFixes) {
+                            results.push(`- **${cubeName}**: ✅ Fixed - ${issues.join(", ")}`);
+                            fixedCount++;
+                        }
+                        else if (fixError) {
+                            results.push(`- **${cubeName}**: ❌ Error - ${fixError}`);
+                            errorCount++;
+                        }
+                    }
+                    else {
+                        results.push(`- **${cubeName}**: ⚠️ Issues - ${issues.join(", ")}`);
+                        errorCount++;
+                    }
+                }
+                else {
+                    results.push(`- **${cubeName}**: ✅ OK`);
+                    okCount++;
+                }
+            }
+            catch (err) {
+                results.push(`- **${cubeName}**: ❌ Error reading config - ${err}`);
+                errorCount++;
+            }
+        }
+        results.push("\n### Summary");
+        results.push(`- ✅ OK: ${okCount}`);
+        if (fixedCount > 0)
+            results.push(`- 🔧 Fixed: ${fixedCount}`);
+        if (errorCount > 0)
+            results.push(`- ⚠️ Issues: ${errorCount}`);
+        if (fixedCount > 0)
+            results.push("\n**Note:** Fixed cubes need API restart to take effect.");
+        return [{ type: "text", text: results.join("\n") }];
+    }
+    catch (err) {
+        return apiErrorResponse("Validation", String(err));
+    }
+}
+// ============================================================================
+// memos_delete
+// ============================================================================
+export async function handleMemosDelete(arguments_) {
+    if (!MEMOS_ENABLE_DELETE) {
+        return errorResponse("Delete functionality is disabled", ERR_DELETE_DISABLED, [
+            "Set MEMOS_ENABLE_DELETE=true in environment to enable",
+            "This is a safety feature to prevent accidental data loss",
+        ]);
+    }
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const memoryId = arguments_.memory_id ? String(arguments_.memory_id) : undefined;
+    const memoryIds = Array.isArray(arguments_.memory_ids)
+        ? arguments_.memory_ids.map(String)
+        : [];
+    const deleteAll = arguments_.delete_all === true;
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    if (deleteAll) {
+        const response = await fetchWithTimeout(`${MEMOS_URL}/memories/${cubeId}?user_id=${encodeURIComponent(MEMOS_USER)}`, { method: "DELETE" });
+        if (response.ok) {
+            const data = await response.json();
+            if (data.code === 200) {
+                return [{ type: "text", text: `⚠️ **ALL memories deleted** from cube: \`${cubeId}\`` }];
+            }
+            else {
+                return errorResponse(`❌ **Delete all failed**: ${data.message ?? "Unknown error"}`);
+            }
+        }
+        else {
+            return errorResponse(`❌ **API error** during delete all: ${response.status}`);
+        }
+    }
+    const idsToDelete = [];
+    if (memoryId)
+        idsToDelete.push(memoryId);
+    idsToDelete.push(...memoryIds);
+    if (idsToDelete.length === 0) {
+        return errorResponse("No target specified for deletion", ERR_PARAM_MISSING, [
+            "Provide `memory_id` for single delete",
+            "Provide `memory_ids` for batch delete",
+            "Set `delete_all=true` to delete all memories (dangerous)",
+        ]);
+    }
+    const results = [];
+    for (const mid of idsToDelete) {
+        let memContent = "*(Unknown content)*";
+        try {
+            const getResp = await fetchWithTimeout(`${MEMOS_URL}/memories/${cubeId}/${mid}?user_id=${encodeURIComponent(MEMOS_USER)}`, { method: "GET" });
+            if (getResp.ok) {
+                const gData = await getResp.json();
+                if (gData.code === 200 && gData.data) {
+                    const memNode = gData.data;
+                    if (typeof memNode === "object") {
+                        memContent = String(memNode.memory ?? memContent);
+                    }
+                }
+            }
+        }
+        catch {
+            memContent = "*(Fetch failed)*";
+        }
+        const deleteResp = await fetchWithTimeout(`${MEMOS_URL}/memories/${cubeId}/${mid}?user_id=${encodeURIComponent(MEMOS_USER)}`, { method: "DELETE" });
+        if (deleteResp.ok) {
+            const data = await deleteResp.json();
+            if (data.code === 200) {
+                results.push(`✅ Deleted: \`${mid}\`\n   > ${memContent.slice(0, 150)}...`);
+            }
+            else {
+                results.push(`❌ Failed: \`${mid}\` (${data.message ?? "Unknown error"})`);
+            }
+        }
+        else {
+            results.push(`❌ API Error: \`${mid}\` (Status: ${deleteResp.status})`);
+        }
+    }
+    return [{ type: "text", text: results.join("\n") }];
+}
+//# sourceMappingURL=admin.js.map

package/dist/handlers/calendar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calendar Handler
+ *
+ * memos_calendar - project mode and student mode
+ */
+import type { TextContent } from "../types.js";
+export declare function handleMemosCalendar(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+//# sourceMappingURL=calendar.d.ts.map

package/dist/handlers/calendar.js

@@ -0,0 +1,281 @@
+/**
+ * Calendar Handler
+ *
+ * memos_calendar - project mode and student mode
+ */
+import { MEMOS_URL, MEMOS_USER } from "../config.js";
+import { apiCallWithRetry } from "../api-client.js";
+import { ensureCubeRegistered } from "../cube-manager.js";
+import { apiErrorResponse, cubeRegistrationError, getCubeIdFromArgs } from "./utils.js";
+// ============================================================================
+// Date Utilities
+// ============================================================================
+function getSemesterDates(semester) {
+    const now = new Date();
+    if (semester === "current") {
+        const year = now.getFullYear();
+        const month = now.getMonth() + 1; // 1-based
+        if (month >= 9) {
+            return [new Date(year, 8, 1), new Date(year, 11, 31)];
+        }
+        else if (month >= 2) {
+            return [new Date(year, 1, 1), new Date(year, 5, 30)];
+        }
+        else {
+            return [new Date(year - 1, 8, 1), new Date(year - 1, 11, 31)];
+        }
+    }
+    const parts = semester.split("-");
+    if (parts.length === 2) {
+        const year = parseInt(parts[0]);
+        const season = parts[1].toLowerCase();
+        if (!isNaN(year)) {
+            if (season === "spring")
+                return [new Date(year, 1, 1), new Date(year, 5, 30)];
+            if (season === "fall")
+                return [new Date(year, 8, 1), new Date(year, 11, 31)];
+            if (season === "summer")
+                return [new Date(year, 6, 1), new Date(year, 7, 31)];
+        }
+    }
+    return [new Date(now.getFullYear(), now.getMonth(), 1), now];
+}
+function getWeekDates(semesterStart, week) {
+    const weekStart = new Date(semesterStart.getTime() + (week - 1) * 7 * 24 * 60 * 60 * 1000);
+    const dayOfWeek = weekStart.getDay();
+    const monday = new Date(weekStart.getTime() - ((dayOfWeek + 6) % 7) * 24 * 60 * 60 * 1000);
+    const sunday = new Date(monday.getTime() + 6 * 24 * 60 * 60 * 1000);
+    return [monday, sunday];
+}
+// ============================================================================
+// Project Timeline Formatter
+// ============================================================================
+function formatProjectTimeline(memories, cubeId) {
+    const lines = [];
+    lines.push(`## 🗓️ Project Timeline — ${cubeId}`, "");
+    const projectTypes = new Set(["MILESTONE", "DECISION", "FEATURE", "BUGFIX", "ERROR_PATTERN", "GOTCHA"]);
+    const projectMems = memories.filter((m) => {
+        const t = String(m.memory_type ?? m.type ?? "").toUpperCase();
+        return projectTypes.has(t);
+    });
+    if (projectMems.length === 0) {
+        lines.push("_No project milestones or decisions found._", "");
+        lines.push('Save memories with: memos_save(..., memory_type="MILESTONE")');
+        return lines.join("\n");
+    }
+    // Group by year-month
+    const byMonth = {};
+    for (const mem of projectMems) {
+        const created = String(mem.created_at ?? mem.timestamp ?? "");
+        const monthStr = created.length >= 7 ? created.slice(0, 7) : "unknown";
+        if (!byMonth[monthStr])
+            byMonth[monthStr] = [];
+        byMonth[monthStr].push(mem);
+    }
+    const sortedMonths = Object.keys(byMonth).sort().reverse();
+    for (const monthStr of sortedMonths) {
+        const mems = byMonth[monthStr];
+        lines.push(`**${monthStr}**`);
+        for (let i = 0; i < mems.length; i++) {
+            const mem = mems[i];
+            const memType = String(mem.memory_type ?? mem.type ?? "NOTE").toUpperCase();
+            const content = String(mem.content ?? mem.key ?? "");
+            const summary = content.split("\n")[0].slice(0, 80);
+            const connector = i === mems.length - 1 ? "└──" : "├──";
+            lines.push(`  ${connector} [${memType}] ${summary}`);
+        }
+        lines.push("");
+    }
+    const typeCounts = {};
+    for (const mem of projectMems) {
+        const t = String(mem.memory_type ?? "OTHER").toUpperCase();
+        typeCounts[t] = (typeCounts[t] ?? 0) + 1;
+    }
+    lines.push(`📊 Total: ${projectMems.length} entries across ${sortedMonths.length} month(s)`);
+    const typeStr = Object.entries(typeCounts).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(", ");
+    lines.push(`   Types: ${typeStr}`);
+    return lines.join("\n");
+}
+// ============================================================================
+// Calendar View Formatter
+// ============================================================================
+function formatCalendarOutput(memories, semester, course, week, view) {
+    const lines = [];
+    if (course) {
+        lines.push(`## 📅 ${semester} - ${course}`);
+    }
+    else {
+        lines.push(`## 📅 ${semester} 学期笔记`);
+    }
+    lines.push("");
+    if (memories.length === 0) {
+        lines.push("_暂无笔记_");
+        return lines.join("\n");
+    }
+    // Group by date
+    const byDate = {};
+    for (const mem of memories) {
+        const created = String(mem.created_at ?? mem.timestamp ?? "");
+        const dateStr = created ? created.slice(0, 10) : new Date().toISOString().slice(0, 10);
+        if (!byDate[dateStr])
+            byDate[dateStr] = [];
+        byDate[dateStr].push(mem);
+    }
+    const sortedDates = Object.keys(byDate).sort().reverse();
+    if (view === "list") {
+        lines.push("| 日期 | 类型 | 内容摘要 |");
+        lines.push("|------|------|---------|");
+        for (const dateStr of sortedDates.slice(0, 20)) {
+            for (const mem of byDate[dateStr]) {
+                const memType = String(mem.memory_type ?? mem.type ?? "NOTE");
+                let content = String(mem.content ?? mem.key ?? "").slice(0, 50);
+                if (content.length === 50)
+                    content += "...";
+                content = content.replace(/\|/g, "\\|").replace(/\n/g, " ");
+                lines.push(`| ${dateStr} | ${memType} | ${content} |`);
+            }
+        }
+    }
+    else if (view === "week") {
+        if (week)
+            lines.push(`### 第 ${week} 周`);
+        lines.push("");
+        const weekdays = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"];
+        for (const dateStr of sortedDates.slice(0, 7)) {
+            try {
+                const dt = new Date(dateStr);
+                const weekday = weekdays[(dt.getDay() + 6) % 7];
+                lines.push(`**${dateStr} ${weekday}**`);
+            }
+            catch {
+                lines.push(`**${dateStr}**`);
+            }
+            for (const mem of byDate[dateStr]) {
+                const memType = String(mem.memory_type ?? mem.type ?? "NOTE");
+                const content = String(mem.content ?? mem.key ?? "").slice(0, 60).replace(/\n/g, " ");
+                lines.push(`- [${memType}] ${content}`);
+            }
+            lines.push("");
+        }
+    }
+    else {
+        // month view
+        lines.push("| 日期 | 笔记数 | 类型分布 |");
+        lines.push("|------|--------|---------|");
+        for (const dateStr of sortedDates.slice(0, 30)) {
+            const mems = byDate[dateStr];
+            const types = {};
+            for (const m of mems) {
+                const t = String(m.memory_type ?? "OTHER");
+                types[t] = (types[t] ?? 0) + 1;
+            }
+            const typeStr = Object.entries(types).map(([k, v]) => `${k}:${v}`).join(", ");
+            lines.push(`| ${dateStr} | ${mems.length} | ${typeStr} |`);
+        }
+    }
+    const total = memories.length;
+    const typeCounts = {};
+    for (const mem of memories) {
+        const t = String(mem.memory_type ?? "OTHER");
+        typeCounts[t] = (typeCounts[t] ?? 0) + 1;
+    }
+    lines.push("");
+    lines.push(`📊 总计: ${total} 条笔记`);
+    if (Object.keys(typeCounts).length > 0) {
+        const typeStr = Object.entries(typeCounts).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(", ");
+        lines.push(`   类型: ${typeStr}`);
+    }
+    return lines.join("\n");
+}
+// ============================================================================
+// memos_calendar
+// ============================================================================
+export async function handleMemosCalendar(arguments_) {
+    const cubeId = getCubeIdFromArgs(arguments_);
+    const mode = String(arguments_.mode ?? "student");
+    const semester = String(arguments_.semester ?? "current");
+    const course = arguments_.course ? String(arguments_.course) : undefined;
+    const week = arguments_.week !== undefined ? Number(arguments_.week) : undefined;
+    const view = String(arguments_.view ?? "list");
+    const [regSuccess, regError] = await ensureCubeRegistered(cubeId);
+    if (!regSuccess)
+        return cubeRegistrationError(cubeId, regError);
+    if (mode === "project") {
+        const result = await apiCallWithRetry("GET", `${MEMOS_URL}/memories`, cubeId, { params: { user_id: MEMOS_USER, mem_cube_id: cubeId, limit: 200 } }, ensureCubeRegistered);
+        if (result.success && result.data) {
+            const resultData = result.data.data ?? {};
+            const memories = [];
+            for (const cubeData of resultData.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);
+                }
+            }
+            const output = formatProjectTimeline(memories, cubeId);
+            return [{ type: "text", text: output }];
+        }
+        else if (result.data) {
+            return apiErrorResponse("Calendar", String(result.data.message ?? "Unknown error"));
+        }
+        else {
+            return apiErrorResponse("Calendar", `HTTP ${result.status}`);
+        }
+    }
+    // Student mode
+    let [startDate, endDate] = getSemesterDates(semester);
+    if (week !== undefined) {
+        [startDate, endDate] = getWeekDates(startDate, week);
+    }
+    const result = await apiCallWithRetry("GET", `${MEMOS_URL}/memories`, cubeId, { params: { user_id: MEMOS_USER, mem_cube_id: cubeId, limit: 100 } }, ensureCubeRegistered);
+    if (result.success && result.data) {
+        const resultData = result.data.data ?? {};
+        let memories = [];
+        for (const cubeData of resultData.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);
+            }
+        }
+        // Filter by course
+        if (course) {
+            const courseLower = course.toLowerCase();
+            memories = memories.filter((m) => String(m.content ?? "").toLowerCase().includes(courseLower) ||
+                String(m.tags ?? "").toLowerCase().includes(courseLower));
+        }
+        // Filter by date range
+        const filtered = [];
+        for (const mem of memories) {
+            const created = String(mem.created_at ?? "");
+            if (created) {
+                try {
+                    const dt = new Date(created.replace("Z", "+00:00"));
+                    const dtNoTz = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate());
+                    if (dtNoTz >= startDate && dtNoTz <= endDate) {
+                        filtered.push(mem);
+                    }
+                }
+                catch {
+                    filtered.push(mem);
+                }
+            }
+            else {
+                filtered.push(mem);
+            }
+        }
+        const output = formatCalendarOutput(filtered, semester, course, week, view);
+        return [{ type: "text", text: output }];
+    }
+    else if (result.data) {
+        return apiErrorResponse("Calendar", String(result.data.message ?? "Unknown error"));
+    }
+    else {
+        return apiErrorResponse("Calendar", `HTTP ${result.status}`);
+    }
+}
+//# sourceMappingURL=calendar.js.map

package/dist/handlers/graph.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Graph Handlers
+ *
+ * memos_trace_path, memos_get_graph, memos_export_schema, memos_impact
+ */
+import type { TextContent } from "../types.js";
+export declare function handleMemosTracePath(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosGetGraph(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosExportSchema(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+export declare function handleMemosImpact(arguments_: Record<string, unknown>): Promise<TextContent[]>;
+//# sourceMappingURL=graph.d.ts.map