@astramindapp/mcp-server 0.18.0 → 0.20.0

package/dist/server.js

@@ -293,15 +293,15 @@ function createMindMcpServer(client) {
     // ─── mind_folders ───────────────────────────────────────
     // Organize documents into folders. Folders are a presentation layer — the
     // knowledge graph still indexes every document regardless of folder.
-    server.tool("mind_folders", "Organize your MIND documents into folders. Folders are a presentation layer — the knowledge graph still indexes and retrieves across every document regardless of folder. Use mind_remember to create a document, then mind_folders move_documents to file it. Actions: list, create, rename, move, delete, move_documents.", {
+    server.tool("mind_folders", "Organize your MIND documents into folders. Folders are a presentation layer — the knowledge graph still indexes and retrieves across every document regardless of folder. Use mind_remember to create a document, then mind_folders move_documents to file it. Actions: list, create, rename, move, delete, move_documents, set_hint (set the agent-routing hint read by mind_folder_suggest).", {
         action: zod_1.z
-            .enum(["list", "create", "rename", "move", "delete", "move_documents"])
-            .describe("list (all folders + counts), create (new folder), rename (change a folder's name), move (re-nest a folder), delete (remove a folder — its documents and subfolders move up a level, nothing is deleted), move_documents (file documents into a folder)"),
+            .enum(["list", "create", "rename", "move", "delete", "move_documents", "set_hint"])
+            .describe("list (all folders + counts + routing hints), create (new folder; pass routing_hint to enable agent-routing), rename (change a folder's name), move (re-nest a folder), delete (remove a folder — its documents and subfolders move up a level, nothing is deleted), move_documents (file documents into a folder), set_hint (write/clear the routing_hint that mind_folder_suggest reads)"),
         name: zod_1.z.string().optional().describe("Folder name — required for create and rename"),
         folder_id: zod_1.z
             .string()
             .optional()
-            .describe("Folder id — the folder to rename/move/delete, or the destination for move_documents (omit or pass 'root' to file documents at the top level)"),
+            .describe("Folder id — the folder to rename/move/delete/set_hint, or the destination for move_documents (omit or pass 'root' to file documents at the top level)"),
         parent_id: zod_1.z
             .string()
             .optional()
@@ -310,7 +310,11 @@ function createMindMcpServer(client) {
             .array(zod_1.z.string())
             .optional()
             .describe("Document ids to file — required for move_documents"),
-    }, async ({ action, name, folder_id, parent_id, doc_ids }) => {
+        routing_hint: zod_1.z
+            .string()
+            .optional()
+            .describe("Free-text instruction answering \"when should MIND save things to this folder?\". Read by mind_folder_suggest to LLM-route new content. Pass on create to set up-front; pass on set_hint to update. Pass empty string to clear (disables the folder from auto-routing)."),
+    }, async ({ action, name, folder_id, parent_id, doc_ids, routing_hint }) => {
         try {
             switch (action) {
                 case "list": {
@@ -328,7 +332,9 @@ function createMindMcpServer(client) {
                     const byId = new Map(res.folders.map((f) => [f.id, f]));
                     const lines = res.folders.map((f) => {
                         const parent = f.parent_id ? byId.get(f.parent_id)?.name ?? "?" : "(top level)";
-                        return `• ${f.name} — ${f.document_count ?? 0} doc(s) · id: ${f.id} · parent: ${parent}`;
+                        const hint = (f.routing_hint || "").trim();
+                        const hintTail = hint ? ` · hint: ${hint.length > 80 ? hint.slice(0, 80) + "…" : hint}` : "";
+                        return `• ${f.name} — ${f.document_count ?? 0} doc(s) · id: ${f.id} · parent: ${parent}${hintTail}`;
                     });
                     return {
                         content: [
@@ -346,10 +352,10 @@ function createMindMcpServer(client) {
                 case "create": {
                     if (!name)
                         throw new Error("'name' is required to create a folder");
-                    const res = await client.createFolder(name, parent_id ?? null);
+                    const res = await client.createFolder(name, parent_id ?? null, routing_hint);
                     return {
                         content: [
-                            { type: "text", text: `Created folder "${res.folder.name}" (id: ${res.folder.id})` },
+                            { type: "text", text: `Created folder "${res.folder.name}" (id: ${res.folder.id})${routing_hint ? " · routing hint set" : ""}` },
                         ],
                     };
                 }
@@ -404,6 +410,24 @@ function createMindMcpServer(client) {
                         ],
                     };
                 }
+                case "set_hint": {
+                    if (!folder_id)
+                        throw new Error("'folder_id' is required to set a routing hint");
+                    if (routing_hint === undefined)
+                        throw new Error("'routing_hint' is required for set_hint (pass empty string to clear)");
+                    const res = await client.updateFolder(folder_id, { routing_hint });
+                    const cleared = !routing_hint.trim();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: cleared
+                                    ? `Cleared routing hint on "${res.folder.name}" — folder is no longer auto-routed.`
+                                    : `Routing hint set on "${res.folder.name}". mind_folder_suggest will now consider this folder.`,
+                            },
+                        ],
+                    };
+                }
                 default:
                     throw new Error(`Unknown action: ${action}`);
             }
@@ -415,6 +439,154 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── mind_folder_routes ─────────────────────────────────
+    // Deterministic per-source_type system-folder routing. Configure once
+    // and every life_item / crm / chat-save / etc. lands in its designated
+    // folder automatically. ``apply_recommended`` is the one-tap setup.
+    server.tool("mind_folder_routes", "Configure deterministic system-folder routing — which folder each kind of system-generated doc (life items, CRM, chat saves, tasks, training, reasoning trajectories, playbooks, trader signals, cloud imports) is filed into automatically. Actions: list, set, clear, apply_recommended (idempotent one-tap setup that creates Life/CRM/Chats/Reasoning/Trader folders and wires every source_type to its destination). User uploads are unaffected — this is system writes only.", {
+        action: zod_1.z
+            .enum(["list", "set", "clear", "apply_recommended"])
+            .describe("list (current routing table + every supported source_type with label/description), set (route one source_type to a folder), clear (remove a route — that source_type goes to the top level again), apply_recommended (create Life/CRM/Chats/Reasoning/Trader folders if missing and wire all routes; idempotent and safe to re-run)"),
+        source_type: zod_1.z
+            .string()
+            .optional()
+            .describe("Required for set and clear. Canonical values: life_item, task, crm, chat, training, trajectory, playbook, trader, document. Custom values accepted (the route will fire whenever save_document_record is called with that source_type)."),
+        folder_id: zod_1.z
+            .string()
+            .optional()
+            .describe("Required for set — the folder id to route this source_type into."),
+    }, async ({ action, source_type, folder_id }) => {
+        try {
+            switch (action) {
+                case "list": {
+                    const res = await client.listFolderRoutes();
+                    const folders = await client.listFolders();
+                    const folderById = new Map(folders.folders.map((f) => [f.id, f]));
+                    const lines = res.categories.map((cat) => {
+                        const fid = res.routes[cat.source_type];
+                        const folder = fid ? folderById.get(fid) : null;
+                        const dest = folder
+                            ? `→ ${folder.name} (id: ${fid})`
+                            : "→ (unrouted — files at top level)";
+                        return `• ${cat.label} [${cat.source_type}] ${dest}\n  ${cat.description}`;
+                    });
+                    const configured = Object.keys(res.routes).length;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: [
+                                    `${configured}/${res.categories.length} routes configured.`,
+                                    "",
+                                    ...lines,
+                                ].join("\n"),
+                            },
+                        ],
+                    };
+                }
+                case "set": {
+                    if (!source_type)
+                        throw new Error("'source_type' is required");
+                    if (!folder_id)
+                        throw new Error("'folder_id' is required for set");
+                    await client.setFolderRoute(source_type, folder_id);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Routed source_type "${source_type}" → folder ${folder_id}. Future writes of that type will file there automatically.`,
+                            },
+                        ],
+                    };
+                }
+                case "clear": {
+                    if (!source_type)
+                        throw new Error("'source_type' is required");
+                    await client.clearFolderRoute(source_type);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Cleared route for "${source_type}". Future writes of that type land at the top level.`,
+                            },
+                        ],
+                    };
+                }
+                case "apply_recommended": {
+                    const res = await client.applyRecommendedFolders();
+                    const lines = [];
+                    if (res.created.length)
+                        lines.push(`Created: ${res.created.join(", ")}`);
+                    if (res.reused.length)
+                        lines.push(`Reused: ${res.reused.join(", ")}`);
+                    if (res.hint_updated.length)
+                        lines.push(`Hints filled: ${res.hint_updated.join(", ")}`);
+                    lines.push("");
+                    lines.push(`${res.routes_set.length} routes set:`);
+                    for (const r of res.routes_set) {
+                        lines.push(`  • ${r.source_type} → ${r.folder_name}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+        }
+        catch (err) {
+            return {
+                content: [
+                    { type: "text", text: `Error managing folder routes: ${err}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_folder_suggest ─────────────────────────────────
+    // LLM-driven content-aware folder picker. Reads every folder's
+    // routing_hint and chooses the best match (or null when nothing fits).
+    server.tool("mind_folder_suggest", "Ask MIND which folder a piece of content belongs in. Reads every folder's routing_hint (set via mind_folders set_hint) and uses a cheap LLM to pick the best match. Returns folder_id=null when no folder's hint clearly applies — in that case leave the doc unfiled rather than guess. Typical agent flow: suggest → mind_remember (create the doc) → mind_folders move_documents (file it to the suggested folder).", {
+        content: zod_1.z
+            .string()
+            .describe("The text of the new document you're about to file. The picker reads it against every folder's routing_hint."),
+        title: zod_1.z
+            .string()
+            .optional()
+            .describe("Optional title — helps the picker disambiguate short content."),
+    }, async ({ content, title }) => {
+        try {
+            const res = await client.suggestFolder(content, title);
+            if (!res.folder_id) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No folder match — ${res.reason}\n\nLeave the doc unfiled or call mind_folder_routes apply_recommended to set up the default folder layout.`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `Suggested folder: ${res.folder_name} (id: ${res.folder_id})`,
+                            `Confidence: ${Math.round(res.confidence * 100)}%`,
+                            `Reason: ${res.reason}`,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    { type: "text", text: `Error suggesting folder: ${err}` },
+                ],
+                isError: true,
+            };
+        }
+    });
     // ─── mind_context ───────────────────────────────────────
     // Get structured always-loaded context.
     // Equivalent to OpenClaw's SOUL.md + USER.md + AGENTS.md bootstrap injection,
@@ -453,14 +625,15 @@ function createMindMcpServer(client) {
     // ─── mind_life ──────────────────────────────────────────
     // Read/write goals, projects, tasks, calendar events, stats.
     // Enhanced: calendar CRUD, stats, move, get.
-    server.tool("mind_life", "Manage Focus → Project → Outcome hierarchy + calendar in MIND Life. Items are either projects (top-level domain/client buckets that live inside a Focus) or outcomes (deliverables that live under a parent project). Use `item_type` + `parent_id` + `focus_id` on create/update to wire the hierarchy. Use list filters (item_type, parent_id, focus_id, top_level_only) to slice the board.", {
+    server.tool("mind_life", "Manage Focus → Project → Outcome hierarchy + calendar in MIND Life. Items are either projects (top-level domain/client buckets that live inside a Focus) or outcomes (deliverables that live under a parent project). Use `item_type` + `parent_id` + `focus_id` on create/update to wire the hierarchy. Use list filters (item_type, parent_id, focus_id, top_level_only) to slice the board. Share a project with another MIND account using share/list_shares/revoke_share (requires LIFE_SHARING_ENABLED on the backend; grantee gets the project + its outcomes on their board).", {
         action: zod_1.z
             .enum([
             "list", "create", "update", "complete", "delete", "bulk_delete", "move", "get",
             "calendar_list", "calendar_create", "calendar_update", "calendar_delete",
             "stats",
+            "share", "list_shares", "revoke_share",
         ])
-            .describe("What to do: list/create/update/complete/delete/bulk_delete/move/get items, calendar_list/calendar_create/calendar_update/calendar_delete events, stats (productivity overview)"),
+            .describe("What to do: list/create/update/complete/delete/bulk_delete/move/get items, calendar_list/calendar_create/calendar_update/calendar_delete events, stats (productivity overview), share (grant another MIND account access to a project) / list_shares (who a project is shared with) / revoke_share (drop a grant)"),
         title: zod_1.z.string().optional().describe("Title for new items or calendar events"),
         description: zod_1.z.string().optional().describe("Description for new items"),
         status: zod_1.z
@@ -501,7 +674,13 @@ function createMindMcpServer(client) {
         top_level_only: zod_1.z.boolean().optional().describe("On list — true returns only items with no parent (board roots: projects + unassigned outcomes)."),
         include_completed: zod_1.z.boolean().optional().describe("On list — false hides completed items. Defaults true."),
         limit: zod_1.z.number().int().min(1).max(500).optional().describe("On list — max items to return (1–500, default 30)."),
-    }, async ({ action, title, description, status, priority, due_date, item_id, item_ids, start_time, end_time, event_id, all_day, tags, color, target_date, item_type, parent_id, focus_id, agent_ids, workflow_ids, top_level_only, include_completed, limit }) => {
+        grantee_username: zod_1.z.string().optional().describe("Username to grant access to (action=share). Must be an existing MIND account."),
+        share_role: zod_1.z
+            .enum(["owner", "viewer"])
+            .optional()
+            .describe("Role for the grant (action=share). 'owner' = full control over the project + its outcomes. 'viewer' = read-only. Default: viewer."),
+        share_id: zod_1.z.string().optional().describe("Share-grant id to revoke (action=revoke_share). Get it from action=list_shares."),
+    }, async ({ action, title, description, status, priority, due_date, item_id, item_ids, start_time, end_time, event_id, all_day, tags, color, target_date, item_type, parent_id, focus_id, agent_ids, workflow_ids, top_level_only, include_completed, limit, grantee_username, share_role, share_id }) => {
         try {
             switch (action) {
                 case "list": {
@@ -801,6 +980,59 @@ function createMindMcpServer(client) {
                     }
                     return { content: [{ type: "text", text: lines.join("\n") }] };
                 }
+                case "share": {
+                    if (!item_id || !grantee_username) {
+                        return {
+                            content: [{ type: "text", text: "Error: item_id (project id) and grantee_username are required for share" }],
+                            isError: true,
+                        };
+                    }
+                    const role = share_role ?? "viewer";
+                    const grant = await client.addLifeShare(item_id, grantee_username, role);
+                    const label = grant.grantee_label && grant.grantee_label !== grant.grantee_username
+                        ? `${grant.grantee_label} (@${grant.grantee_username})`
+                        : `@${grant.grantee_username}`;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Shared project "${grant.project_title ?? grant.project_id}" with ${label} as ${grant.role} (share id: ${grant.id})`,
+                            },
+                        ],
+                    };
+                }
+                case "list_shares": {
+                    if (!item_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: item_id (project id) is required for list_shares" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.listLifeShares(item_id);
+                    const shares = result.shares ?? [];
+                    if (shares.length === 0) {
+                        return { content: [{ type: "text", text: "No shares on this project yet." }] };
+                    }
+                    const lines = shares.map((s) => {
+                        const label = s.grantee_label && s.grantee_label !== s.grantee_username
+                            ? `${s.grantee_label} (@${s.grantee_username})`
+                            : `@${s.grantee_username}`;
+                        return `• ${label} — ${s.role}${s.granted_by ? ` (granted by @${s.granted_by})` : ""} — id: ${s.id}`;
+                    });
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "revoke_share": {
+                    if (!item_id || !share_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: item_id (project id) and share_id are required for revoke_share. Get the share_id from action=list_shares." }],
+                            isError: true,
+                        };
+                    }
+                    await client.revokeLifeShare(item_id, share_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Revoked share ${share_id} on project ${item_id}` }],
+                    };
+                }
             }
         }
         catch (err) {