@agilsee/mcp-orchestrator 0.5.0

package/dist/index.js

@@ -0,0 +1,454 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { getIdentity } from "./tools/get-identity.js";
+import { getCurrentFocus } from "./tools/get-focus.js";
+import { listProjects } from "./tools/list-projects.js";
+import { getProjectStatus } from "./tools/get-project-status.js";
+import { listRecentTasks } from "./tools/list-recent-tasks.js";
+import { switchFocus } from "./tools/switch-focus.js";
+import { logInsight } from "./tools/log-insight.js";
+import { checkEnergy } from "./tools/check-energy.js";
+import { aggregatePatterns } from "./tools/aggregate-patterns.js";
+import { analyzeHistory } from "./tools/analyze-history.js";
+import { summarizeLastSession } from "./tools/summarize-session.js";
+import { qccCreate } from "./tools/qcc-create.js";
+import { qccUpdate } from "./tools/qcc-update.js";
+import { qccStatus } from "./tools/qcc-status.js";
+import { smartBootstrap } from "./tools/smart-bootstrap.js";
+import { workflowRouter } from "./tools/workflow-router.js";
+import { saveMemory, searchMemory, listMemories, deleteMemory } from "./memory/memory-manager.js";
+import { autoDispatch } from "./tools/auto-dispatch.js";
+import { crossSearch } from "./tools/cross-search.js";
+const CLAUDE_HOME = process.env.CLAUDE_HOME ?? `${process.env.USERPROFILE ?? process.env.HOME}/.claude`;
+const server = new Server({ name: "orchestrator", version: "0.1.0" }, { capabilities: { tools: {} } });
+const tools = [
+    {
+        name: "get_identity",
+        description: "Dapatkan identitas agent (nama, author, spesialisasi). Baca agent-identity.json.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "get_current_focus",
+        description: "Dapatkan focus profile aktif + project yang sedang jadi prioritas kerja. Baca current-focus.json.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "list_projects",
+        description: "List semua project terdaftar di project-registry.json dengan metadata singkat (stack, status, group).",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "get_project_status",
+        description: "Baca CURRENT_STATE.md project tertentu, return task aktif + yang baru selesai.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "Project slug, misal 'app-fe'" },
+            },
+            required: ["slug"],
+        },
+    },
+    {
+        name: "list_recent_tasks",
+        description: "Parse AUDIT_LOG.md (satu project atau semua) → return task terbaru diurutkan desc. Lebih hemat daripada Read file manual.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: {
+                    type: "string",
+                    description: "Optional: project slug tertentu. Kosong = gabungan semua project.",
+                },
+                limit: { type: "number", description: "Jumlah entry, default 10" },
+            },
+        },
+    },
+    {
+        name: "switch_focus",
+        description: "Ganti focus profile aktif (sesuai key di current-focus.json). Update current-focus.json.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                profile: {
+                    type: "string",
+                    description: "Profile key sesuai yang didefinisikan di current-focus.json — atau 'general' untuk mode default.",
+                },
+            },
+            required: ["profile"],
+        },
+    },
+    {
+        name: "log_insight",
+        description: "Catat insight lintas project (pattern, feedback, gotcha, workflow). Simpan ke INSIGHTS.md global.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    enum: ["cross_project_pattern", "feedback", "workflow", "gotcha"],
+                    description: "Tipe insight",
+                },
+                title: { type: "string", description: "Judul singkat" },
+                detail: { type: "string", description: "Penjelasan detail" },
+                projects: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Project yang terlibat",
+                },
+                source: { type: "string", description: "Sumber: user feedback, bug trace, review, dll" },
+            },
+            required: ["type", "title", "detail", "projects"],
+        },
+    },
+    {
+        name: "check_energy",
+        description: "Cek apakah sekarang di luar jam kerja developer (Senin-Jumat 08:00-17:00 WIB). Jika ya, return warning. WAJIB panggil di awal sesi.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "aggregate_patterns",
+        description: "Scan MISTAKES.md dari semua project, deteksi cross-project pattern. Bisa filter by keyword untuk cek apakah bug sudah pernah terjadi di project lain.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                keyword: {
+                    type: "string",
+                    description: "Optional: keyword untuk search across semua MISTAKES.md",
+                },
+            },
+        },
+    },
+    {
+        name: "analyze_history",
+        description: "Otak MCP: analisis AUDIT_LOG + MISTAKES semua project → return hotspot files, repeat bugs, warnings, dan suggestions. Panggil di awal sesi atau sebelum mulai task untuk dapat konteks sejarah.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "summarize_last_session",
+        description: "Narrative TL;DR dari sesi sebelumnya — baca AUDIT_LOG + MISTAKES + CURRENT_STATE untuk semua active_projects di current-focus.json. Return: recent tasks, open bugs, active tasks, plus TL;DR terstruktur. WAJIB panggil di awal sesi baru, setelah get_current_focus.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Jumlah recent task & mistake per project, default 5",
+                },
+            },
+        },
+    },
+    {
+        name: "smart_bootstrap",
+        description: "1 panggilan = semua context sesi. Gabungan: identity + focus + energy + project status + QCC aktif + recent mistakes + suggested next action + suggested skill. WAJIB panggil di awal sesi, gantikan 5 tool calls terpisah.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "workflow_router",
+        description: "Auto-detect intent user → return workflow terstruktur (urutan tool + skill yang harus dipanggil). Intent: debug, new-feature, fix-bug, qcc, refactor, explore, review. Panggil SEBELUM mulai kerja supaya ada arah.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                intent: {
+                    type: "string",
+                    description: "Apa yang mau dilakukan, misal 'debug order timeout', 'bikin fitur export PDF', 'fix bug invoice'",
+                },
+                module: {
+                    type: "string",
+                    description: "Optional: module/area terkait (order, quotation, invoice, sample, dll)",
+                },
+                detail: {
+                    type: "string",
+                    description: "Optional: detail tambahan (function name, error message, dll)",
+                },
+            },
+            required: ["intent"],
+        },
+    },
+    {
+        name: "qcc_create",
+        description: "Buat QCC cycle baru (Step 1: Tema & Focus Target). Auto-generate QCC ID, init structure 8 langkah di QCC_CYCLES.md.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "Project slug, misal 'app-fe'" },
+                theme: { type: "string", description: "Tema QCC — deskripsi masalah utama" },
+                focus_target: { type: "string", description: "Fokus target spesifik (modul/area/metric)" },
+            },
+            required: ["slug", "theme", "focus_target"],
+        },
+    },
+    {
+        name: "qcc_update",
+        description: "Update step tertentu dalam QCC cycle (Step 2-8). Setiap step punya structure data berbeda: kondisi, SMART target, fishbone, rencana, pelaksanaan, evaluasi, validasi.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "Project slug" },
+                qcc_id: { type: "string", description: "QCC ID, misal 'QCC-001'" },
+                data: {
+                    type: "object",
+                    description: "Step data. Harus include 'step' (2-8) + field sesuai step. Step 2: {step,findings[]}, Step 3: {step,smart:{specific,measurable,achievable,relevant,timebound}}, Step 4: {step,root_problem,causes:[{category,items[]}]}, Step 5: {step,countermeasures:[{cause,action,pic,target_date}]}, Step 6: {step,execution:{no,status,date?,notes?}}, Step 7: {step,evaluation:{before,after,target_achieved,notes?}}, Step 8: {step,validation:{validated_by,date?,standardization?,horizontal_deploy?}}",
+                },
+            },
+            required: ["slug", "qcc_id", "data"],
+        },
+    },
+    {
+        name: "qcc_status",
+        description: "Lihat status QCC cycles — semua project atau project tertentu. Return: summary per cycle, steps done/pending, current step.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "Optional: project slug. Kosong = semua project." },
+                qcc_id: { type: "string", description: "Optional: QCC ID tertentu untuk detail." },
+            },
+        },
+    },
+    {
+        name: "save_memory",
+        description: "Simpan memory persisten (keputusan, insight, bug, konteks, catatan) ke Loki.js DB. Memory otomatis searchable di sesi berikutnya. Gunakan untuk menyimpan informasi penting yang harus diingat antar sesi.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    enum: ["session_summary", "decision", "insight", "bug", "context", "user_note"],
+                    description: "Tipe memory: session_summary (ringkasan sesi), decision (keputusan teknis), insight (temuan), bug (bug ditemukan), context (konteks project), user_note (catatan user)",
+                },
+                project: { type: "string", description: "Optional: project slug (misal 'app-fe', 'app-be')" },
+                title: { type: "string", description: "Judul singkat memory" },
+                content: { type: "string", description: "Isi detail memory" },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Tags untuk search, boleh bilingual: ['order', 'pesanan', 'timeout']",
+                },
+                session_id: { type: "string", description: "Optional: session identifier" },
+            },
+            required: ["type", "title", "content"],
+        },
+    },
+    {
+        name: "search_memory",
+        description: "Cari memory dengan full-text search (TF-IDF ranking + fuzzy match). Bisa filter by type & project. WAJIB panggil di awal sesi untuk load konteks dari sesi sebelumnya.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query — bisa keyword, kalimat, bahkan typo" },
+                type: {
+                    type: "string",
+                    enum: ["session_summary", "decision", "insight", "bug", "context", "user_note"],
+                    description: "Optional: filter by type",
+                },
+                project: { type: "string", description: "Optional: filter by project slug" },
+                limit: { type: "number", description: "Max results, default 10" },
+                fuzzy: { type: "number", description: "Fuzzy tolerance 0-1, default 0.2" },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "list_memories",
+        description: "List semua memory dengan pagination. Return preview (150 char), bukan full content — hemat token. Untuk detail, pakai search_memory.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    enum: ["session_summary", "decision", "insight", "bug", "context", "user_note"],
+                    description: "Optional: filter by type",
+                },
+                project: { type: "string", description: "Optional: filter by project slug" },
+                limit: { type: "number", description: "Max results per page, default 20" },
+                offset: { type: "number", description: "Skip N results, default 0" },
+            },
+        },
+    },
+    {
+        name: "delete_memory",
+        description: "Hapus memory by ID. Gunakan list_memories atau search_memory dulu untuk dapat ID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Memory ID, misal 'mem_abc123_xyz'" },
+            },
+            required: ["id"],
+        },
+    },
+    {
+        name: "auto_dispatch",
+        description: "AUTONOMOUS DISPATCHER — Analisis query user, detect module & intent, search memory, lalu return dispatch plan berisi EXACT MCP tool calls yang harus dieksekusi di agent masing-masing. Panggil ini ketika user melaporkan bug/masalah/request yang melibatkan project. Agent Claude WAJIB eksekusi tool calls sesuai plan yang dikembalikan.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Query user apa adanya, misal 'ada bug di invoice', 'trace flow order', 'bikin fitur export PDF'",
+                },
+                force_projects: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: paksa dispatch ke project tertentu. Default: auto-detect dari module.",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "cross_search",
+        description: "Cari informasi di SEMUA project sekaligus — MISTAKES.md, CURRENT_STATE.md, AUDIT_LOG.md, dan opsional code files. Berguna untuk: cek apakah bug sudah pernah terjadi di project lain, find cross-project patterns, atau cari keyword di seluruh ekosistem.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query — keyword atau kalimat",
+                },
+                scope: {
+                    type: "string",
+                    description: "Optional: filter by project slug atau group name (sesuai field 'group' di project-registry.json). Default: semua active projects.",
+                },
+                include_code: {
+                    type: "boolean",
+                    description: "Optional: juga scan code files (lebih lambat). Default: false — hanya scan docs.",
+                },
+            },
+            required: ["query"],
+        },
+    },
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        switch (name) {
+            case "get_identity":
+                result = await getIdentity(CLAUDE_HOME);
+                break;
+            case "get_current_focus":
+                result = await getCurrentFocus(CLAUDE_HOME);
+                break;
+            case "list_projects":
+                result = await listProjects(CLAUDE_HOME);
+                break;
+            case "get_project_status":
+                result = await getProjectStatus(CLAUDE_HOME, String(args?.slug ?? ""));
+                break;
+            case "list_recent_tasks":
+                result = await listRecentTasks(CLAUDE_HOME, args?.slug ? String(args.slug) : undefined, typeof args?.limit === "number" ? args.limit : 10);
+                break;
+            case "switch_focus":
+                result = await switchFocus(CLAUDE_HOME, String(args?.profile ?? ""));
+                break;
+            case "log_insight":
+                result = await logInsight(CLAUDE_HOME, {
+                    type: String(args?.type ?? "feedback"),
+                    title: String(args?.title ?? ""),
+                    detail: String(args?.detail ?? ""),
+                    projects: Array.isArray(args?.projects) ? args.projects.map(String) : [],
+                    source: args?.source ? String(args.source) : undefined,
+                });
+                break;
+            case "check_energy":
+                result = checkEnergy();
+                break;
+            case "aggregate_patterns":
+                result = await aggregatePatterns(CLAUDE_HOME, args?.keyword ? String(args.keyword) : undefined);
+                break;
+            case "analyze_history":
+                result = await analyzeHistory(CLAUDE_HOME);
+                break;
+            case "summarize_last_session":
+                result = await summarizeLastSession(CLAUDE_HOME, typeof args?.limit === "number" ? args.limit : 5);
+                break;
+            case "smart_bootstrap":
+                result = await smartBootstrap(CLAUDE_HOME);
+                break;
+            case "workflow_router":
+                result = await workflowRouter(CLAUDE_HOME, {
+                    intent: String(args?.intent ?? ""),
+                    module: args?.module ? String(args.module) : undefined,
+                    detail: args?.detail ? String(args.detail) : undefined,
+                });
+                break;
+            case "qcc_create":
+                result = await qccCreate(CLAUDE_HOME, {
+                    slug: String(args?.slug ?? ""),
+                    theme: String(args?.theme ?? ""),
+                    focus_target: String(args?.focus_target ?? ""),
+                });
+                break;
+            case "qcc_update":
+                result = await qccUpdate(CLAUDE_HOME, {
+                    slug: String(args?.slug ?? ""),
+                    qcc_id: String(args?.qcc_id ?? ""),
+                    data: args?.data,
+                });
+                break;
+            case "qcc_status":
+                result = await qccStatus(CLAUDE_HOME, args?.slug ? String(args.slug) : undefined, args?.qcc_id ? String(args.qcc_id) : undefined);
+                break;
+            case "save_memory":
+                result = await saveMemory(CLAUDE_HOME, {
+                    type: String(args?.type ?? "user_note"),
+                    project: args?.project ? String(args.project) : undefined,
+                    title: String(args?.title ?? ""),
+                    content: String(args?.content ?? ""),
+                    tags: Array.isArray(args?.tags) ? args.tags.map(String) : undefined,
+                    session_id: args?.session_id ? String(args.session_id) : undefined,
+                });
+                break;
+            case "search_memory":
+                result = await searchMemory(CLAUDE_HOME, {
+                    query: String(args?.query ?? ""),
+                    type: args?.type ? String(args.type) : undefined,
+                    project: args?.project ? String(args.project) : undefined,
+                    limit: typeof args?.limit === "number" ? args.limit : 10,
+                    fuzzy: typeof args?.fuzzy === "number" ? args.fuzzy : 0.2,
+                });
+                break;
+            case "list_memories":
+                result = await listMemories(CLAUDE_HOME, {
+                    type: args?.type ? String(args.type) : undefined,
+                    project: args?.project ? String(args.project) : undefined,
+                    limit: typeof args?.limit === "number" ? args.limit : 20,
+                    offset: typeof args?.offset === "number" ? args.offset : 0,
+                });
+                break;
+            case "delete_memory":
+                result = await deleteMemory(CLAUDE_HOME, String(args?.id ?? ""));
+                break;
+            case "auto_dispatch":
+                result = await autoDispatch(CLAUDE_HOME, {
+                    query: String(args?.query ?? ""),
+                    force_projects: Array.isArray(args?.force_projects) ? args.force_projects.map(String) : undefined,
+                });
+                break;
+            case "cross_search":
+                result = await crossSearch(CLAUDE_HOME, {
+                    query: String(args?.query ?? ""),
+                    scope: args?.scope ? String(args.scope) : undefined,
+                    include_code: args?.include_code === true,
+                });
+                break;
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(`[orchestrator-mcp] connected. CLAUDE_HOME=${CLAUDE_HOME}`);

package/dist/memory/memory-manager.js

@@ -0,0 +1,234 @@
+/**
+ * Memory Manager — Loki.js (storage) + MiniSearch (search)
+ *
+ * Auto-persist ke ~/.claude/data/memory.json
+ * Full-text search dengan TF-IDF ranking + fuzzy match
+ */
+import loki from "lokijs";
+import MiniSearch from "minisearch";
+import { mkdirSync, existsSync } from "fs";
+import { join } from "path";
+let db = null;
+let searchIndex = null;
+let memoriesCollection = null;
+let isInitialized = false;
+function getDbPath(claudeHome) {
+    const dataDir = join(claudeHome, "data");
+    if (!existsSync(dataDir)) {
+        mkdirSync(dataDir, { recursive: true });
+    }
+    return join(dataDir, "memory.json");
+}
+function generateId() {
+    const ts = Date.now().toString(36);
+    const rand = Math.random().toString(36).substring(2, 8);
+    return `mem_${ts}_${rand}`;
+}
+function rebuildSearchIndex(entries) {
+    searchIndex = new MiniSearch({
+        fields: ["title", "content", "tags_str", "project", "type"],
+        storeFields: ["id", "title", "type", "project", "created_at", "tags"],
+        searchOptions: {
+            boost: { title: 3, tags_str: 2, content: 1 },
+            prefix: true,
+            fuzzy: 0.2,
+        },
+    });
+    const docs = entries.map((e) => ({
+        id: e.id,
+        title: e.title,
+        content: e.content,
+        tags_str: (e.tags || []).join(" "),
+        project: e.project || "",
+        type: e.type,
+        created_at: e.created_at,
+        tags: e.tags,
+    }));
+    searchIndex.addAll(docs);
+}
+export function initMemory(claudeHome) {
+    if (isInitialized && db)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const dbPath = getDbPath(claudeHome);
+        db = new loki(dbPath, {
+            autoload: true,
+            autosave: true,
+            autosaveInterval: 5000,
+            autoloadCallback: (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                memoriesCollection = db.getCollection("memories");
+                if (!memoriesCollection) {
+                    memoriesCollection = db.addCollection("memories", {
+                        indices: ["type", "project", "created_at"],
+                    });
+                }
+                // Build search index from existing data
+                rebuildSearchIndex(memoriesCollection.find());
+                isInitialized = true;
+                resolve();
+            },
+        });
+    });
+}
+export async function saveMemory(claudeHome, entry) {
+    await initMemory(claudeHome);
+    const now = new Date().toISOString();
+    const id = entry.id || generateId();
+    // Check if updating existing
+    const existing = memoriesCollection.findOne({ id });
+    if (existing) {
+        existing.title = entry.title;
+        existing.content = entry.content;
+        existing.type = entry.type;
+        existing.project = entry.project || existing.project;
+        existing.tags = entry.tags || existing.tags;
+        existing.updated_at = now;
+        memoriesCollection.update(existing);
+        // Rebuild search index
+        rebuildSearchIndex(memoriesCollection.find());
+        await new Promise((resolve, reject) => {
+            db.saveDatabase((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+        return {
+            success: true,
+            id,
+            total_memories: memoriesCollection.count(),
+        };
+    }
+    // New entry
+    const doc = {
+        id,
+        type: entry.type,
+        project: entry.project || "",
+        title: entry.title,
+        content: entry.content,
+        tags: entry.tags || [],
+        session_id: entry.session_id || "",
+        created_at: now,
+        updated_at: now,
+    };
+    memoriesCollection.insert(doc);
+    // Add to search index
+    searchIndex.add({
+        id: doc.id,
+        title: doc.title,
+        content: doc.content,
+        tags_str: doc.tags.join(" "),
+        project: doc.project,
+        type: doc.type,
+        created_at: doc.created_at,
+        tags: doc.tags,
+    });
+    // Force save (with promise wrapper for async safety)
+    await new Promise((resolve, reject) => {
+        db.saveDatabase((err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+    return {
+        success: true,
+        id,
+        total_memories: memoriesCollection.count(),
+    };
+}
+export async function searchMemory(claudeHome, options) {
+    await initMemory(claudeHome);
+    const limit = options.limit || 10;
+    // Full-text search with MiniSearch
+    let results = searchIndex.search(options.query, {
+        fuzzy: options.fuzzy ?? 0.2,
+        prefix: true,
+    });
+    // Filter by type if specified
+    if (options.type) {
+        results = results.filter((r) => r.type === options.type);
+    }
+    // Filter by project if specified
+    if (options.project) {
+        results = results.filter((r) => r.project === options.project);
+    }
+    // Limit results
+    const topResults = results.slice(0, limit);
+    // Fetch full content for top results
+    const detailed = topResults.map((r) => {
+        const full = memoriesCollection.findOne({ id: r.id });
+        return {
+            id: r.id,
+            score: Math.round(r.score * 100) / 100,
+            title: r.title,
+            type: r.type,
+            project: r.project || "",
+            content: full?.content || "",
+            tags: full?.tags || [],
+            created_at: full?.created_at || "",
+            updated_at: full?.updated_at || "",
+        };
+    });
+    return {
+        results: detailed,
+        total_found: results.length,
+        query: options.query,
+    };
+}
+export async function listMemories(claudeHome, options) {
+    await initMemory(claudeHome);
+    let query = {};
+    if (options?.type)
+        query.type = options.type;
+    if (options?.project)
+        query.project = options.project;
+    const allResults = memoriesCollection
+        .chain()
+        .find(query)
+        .simplesort("created_at", { desc: true })
+        .data();
+    const offset = options?.offset || 0;
+    const limit = options?.limit || 20;
+    const sliced = allResults.slice(offset, offset + limit);
+    // Return summary (tanpa full content, hemat token)
+    const memories = sliced.map((m) => ({
+        id: m.id,
+        type: m.type,
+        project: m.project,
+        title: m.title,
+        tags: m.tags,
+        preview: m.content.substring(0, 150) + (m.content.length > 150 ? "..." : ""),
+        created_at: m.created_at,
+        updated_at: m.updated_at,
+    }));
+    return {
+        memories,
+        total: allResults.length,
+        showing: `${offset + 1}-${offset + sliced.length} of ${allResults.length}`,
+    };
+}
+export async function deleteMemory(claudeHome, id) {
+    await initMemory(claudeHome);
+    const existing = memoriesCollection.findOne({ id });
+    if (!existing) {
+        return { success: false, message: `Memory '${id}' not found` };
+    }
+    memoriesCollection.remove(existing);
+    rebuildSearchIndex(memoriesCollection.find());
+    await new Promise((resolve, reject) => {
+        db.saveDatabase((err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+    return { success: true, message: `Memory '${id}' deleted` };
+}