@vheins/local-memory-mcp 0.4.8 → 0.4.11

package/dist/tools/schemas.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
+import { normalizeRepo } from "../utils/normalize.js";
 // Shared schema components
 export const MemoryScopeSchema = z.object({
-    repo: z.string().min(1),
+    repo: z.string().min(1).transform(normalizeRepo),
     branch: z.string().optional(),
     folder: z.string().optional(),
     language: z.string().optional()
@@ -41,7 +42,7 @@ export const MemoryUpdateSchema = z.object({
 export const MemorySearchSchema = z.object({
     query: z.string().min(3),
     prompt: z.string().optional(),
-    repo: z.string().min(1),
+    repo: z.string().min(1).transform(normalizeRepo),
     types: z.array(MemoryTypeSchema).optional(),
     minImportance: z.number().min(1).max(5).optional(),
     limit: z.number().min(1).max(100).default(5),
@@ -57,22 +58,32 @@ export const MemoryAcknowledgeSchema = z.object({
     application_context: z.string().min(10).optional()
 });
 export const MemoryRecapSchema = z.object({
-    repo: z.string().min(1),
+    repo: z.string().min(1).transform(normalizeRepo),
     limit: z.number().min(1).max(50).default(20),
     offset: z.number().min(0).default(0)
 });
 export const MemoryBulkDeleteSchema = z.object({
-    repo: z.string().min(1),
+    repo: z.string().min(1).transform(normalizeRepo),
     ids: z.array(z.string().uuid()).min(1)
 });
 export const MemorySummarizeSchema = z.object({
-    repo: z.string().min(1),
+    repo: z.string().min(1).transform(normalizeRepo),
     signals: z.array(z.string().max(200)).min(1)
 });
+export const MemorySynthesizeSchema = z.object({
+    repo: z.string().min(1).transform(normalizeRepo).optional(),
+    objective: z.string().min(5),
+    current_file_path: z.string().optional(),
+    include_summary: z.boolean().default(true),
+    include_tasks: z.boolean().default(true),
+    use_tools: z.boolean().default(true),
+    max_iterations: z.number().int().min(1).max(5).default(3),
+    max_tokens: z.number().int().min(128).max(4000).default(1200)
+});
 export const TaskStatusSchema = z.enum(["backlog", "pending", "in_progress", "completed", "canceled", "blocked"]);
 export const TaskPrioritySchema = z.number().min(1).max(5);
 export const TaskCreateSchema = z.object({
-    repo: z.string().min(1),
+    repo: z.string().min(1).transform(normalizeRepo),
     task_code: z.string().min(1),
     phase: z.string().min(1),
     title: z.string().min(3).max(100),
@@ -88,8 +99,11 @@ export const TaskCreateSchema = z.object({
     depends_on: z.string().uuid().optional(),
     est_tokens: z.number().int().min(0).optional()
 });
+export const TaskCreateInteractiveSchema = TaskCreateSchema.partial().extend({
+    repo: z.string().min(1).transform(normalizeRepo).optional(),
+});
 export const TaskUpdateSchema = z.object({
-    repo: z.string().min(1),
+    repo: z.string().min(1).transform(normalizeRepo),
     id: z.string().uuid(),
     task_code: z.string().optional(),
     phase: z.string().optional(),
@@ -109,15 +123,23 @@ export const TaskUpdateSchema = z.object({
     est_tokens: z.number().int().min(0).optional()
 }).refine((data) => Object.keys(data).length > 2, { message: "At least one field besides repo and id must be provided for update" });
 export const TaskListSchema = z.object({
-    repo: z.string().min(1),
-    status: TaskStatusSchema.optional(),
+    repo: z.string().min(1).transform(normalizeRepo),
+    status: z.string().optional(),
     phase: z.string().optional(),
+    search: z.string().optional(),
+    limit: z.number().min(1).max(100).default(15),
+    offset: z.number().min(0).default(0)
+});
+export const TaskSearchSchema = z.object({
+    repo: z.string().min(1).transform(normalizeRepo),
+    query: z.string().min(1),
+    status: z.string().optional(),
     limit: z.number().min(1).max(100).default(15),
     offset: z.number().min(0).default(0)
 });
 export const TaskBulkManageSchema = z.object({
     action: z.enum(["bulk_create", "bulk_delete"]),
-    repo: z.string().min(1),
+    repo: z.string().min(1).transform(normalizeRepo),
     tasks: z.array(z.object({
         task_code: z.string().min(1),
         phase: z.string().min(1),
@@ -137,14 +159,99 @@ export const TaskBulkManageSchema = z.object({
     ids: z.array(z.string().uuid()).min(1).optional()
 }).refine((data) => (data.action === "bulk_create" && data.tasks) || (data.action === "bulk_delete" && data.ids), { message: "tasks is required for bulk_create, ids is required for bulk_delete" });
 export const TaskDeleteSchema = z.object({
-    repo: z.string().min(1),
+    repo: z.string().min(1).transform(normalizeRepo),
     id: z.string().uuid()
 });
 // Tool definitions for MCP
 export const TOOL_DEFINITIONS = [
+    {
+        name: "memory-synthesize",
+        title: "Memory Synthesize",
+        description: "Use client sampling to synthesize a grounded answer from local memory and tasks. Best for project briefings, tradeoff summaries, and context-aware answers.",
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        },
+        execution: {
+            taskSupport: "optional"
+        },
+        inputSchema: {
+            type: "object",
+            properties: {
+                repo: { type: "string", description: "Repository name. Optional when a single MCP root is active." },
+                objective: { type: "string", minLength: 5, description: "Question or synthesis objective." },
+                current_file_path: { type: "string", description: "Optional absolute file path for workspace-local grounding." },
+                include_summary: { type: "boolean", default: true },
+                include_tasks: { type: "boolean", default: true },
+                use_tools: { type: "boolean", default: true, description: "Allow the sampled model to call local memory/task tools during synthesis when the client supports sampling.tools." },
+                max_iterations: { type: "number", minimum: 1, maximum: 5, default: 3 },
+                max_tokens: { type: "number", minimum: 128, maximum: 4000, default: 1200 }
+            },
+            required: ["objective"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                repo: { type: "string" },
+                objective: { type: "string" },
+                answer: { type: "string" },
+                model: { type: "string" },
+                stopReason: { type: "string" },
+                iterations: { type: "number" },
+                toolCalls: { type: "number" }
+            },
+            required: ["repo", "objective", "answer", "iterations", "toolCalls"]
+        }
+    },
+    {
+        name: "task-create-interactive",
+        title: "Interactive Task Create",
+        description: "Create a task with MCP elicitation fallback for any missing required fields. Best when an agent knows a task is needed but still needs user confirmation for repo, title, or phase.",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: false,
+            openWorldHint: false
+        },
+        inputSchema: {
+            type: "object",
+            properties: {
+                repo: { type: "string", description: "Repository name. Optional when it can be inferred from MCP roots or elicited from the user." },
+                task_code: { type: "string" },
+                phase: { type: "string" },
+                title: { type: "string", minLength: 3, maxLength: 100 },
+                description: { type: "string", minLength: 1 },
+                status: { type: "string", enum: ["backlog", "pending"], default: "backlog" },
+                priority: { type: "number", minimum: 1, maximum: 5, default: 3 },
+                agent: { type: "string" },
+                role: { type: "string" },
+                doc_path: { type: "string" }
+            }
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                repo: { type: "string" },
+                task_code: { type: "string" },
+                phase: { type: "string" },
+                title: { type: "string" },
+                status: { type: "string" },
+                priority: { type: "number" }
+            },
+            required: ["repo", "task_code", "phase", "title", "status", "priority"]
+        }
+    },
     {
         name: "memory-store",
+        title: "Memory Store",
         description: "Store a new memory entry. Keep 'title' concise and human-readable; do not embed agent/role/date metadata in the title. Put auxiliary context into 'metadata'. Use 'tags' for tech-stack and 'is_global' for universal rules.",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: false,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -205,11 +312,30 @@ export const TOOL_DEFINITIONS = [
                 supersedes: { type: "string", format: "uuid" }
             },
             required: ["type", "title", "content", "importance", "scope", "agent", "model"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                id: { type: "string" },
+                repo: { type: "string" },
+                type: { type: "string" },
+                title: { type: "string" },
+                error: { type: "string" },
+                message: { type: "string" }
+            },
+            required: ["success"]
         }
     },
     {
         name: "memory-acknowledge",
+        title: "Memory Acknowledge",
         description: "Acknowledge the use of a memory or report its irrelevance/contradiction. Mandatory after using memory to generate code.",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -218,11 +344,27 @@ export const TOOL_DEFINITIONS = [
                 application_context: { type: "string", minLength: 10 }
             },
             required: ["memory_id", "status"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                id: { type: "string" },
+                status: { type: "string" }
+            },
+            required: ["success", "id", "status"]
         }
     },
     {
         name: "memory-update",
+        title: "Memory Update",
         description: "Update an existing memory entry. Keep 'title' concise and move agent/role/date or claim context into 'metadata' instead of the title.",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: false,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -238,11 +380,30 @@ export const TOOL_DEFINITIONS = [
                 is_global: { type: "boolean" }
             },
             required: ["id"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                id: { type: "string" },
+                repo: { type: "string" },
+                updatedFields: {
+                    type: "array",
+                    items: { type: "string" }
+                }
+            },
+            required: ["success", "id", "repo", "updatedFields"]
         }
     },
     {
         name: "memory-search",
+        title: "Memory Search",
         description: "Search for relevant memories. Use 'current_tags' to find tech-stack specific knowledge from other projects.",
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -264,11 +425,39 @@ export const TOOL_DEFINITIONS = [
                 include_archived: { type: "boolean", default: false }
             },
             required: ["query", "repo"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string" },
+                recapContext: { type: "string" },
+                results: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string" },
+                            type: { type: "string" },
+                            title: { type: "string" },
+                            content: { type: "string" },
+                            importance: { type: "number" }
+                        },
+                        required: ["id", "type", "content", "importance"]
+                    }
+                }
+            },
+            required: ["query", "results"]
         }
     },
     {
         name: "memory-summarize",
+        title: "Memory Summarize",
         description: "Update the summary for a repository",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -281,22 +470,55 @@ export const TOOL_DEFINITIONS = [
                 }
             },
             required: ["repo", "signals"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                repo: { type: "string" },
+                summary: { type: "string" },
+                signalCount: { type: "number" }
+            },
+            required: ["success", "repo", "summary", "signalCount"]
         }
     },
     {
         name: "memory-delete",
+        title: "Memory Delete",
         description: "Soft-delete a memory entry (remove from active use)",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: true,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
                 id: { type: "string", format: "uuid", description: "Memory entry ID to delete" }
             },
             required: ["id"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                id: { type: "string" },
+                repo: { type: "string" }
+            },
+            required: ["success", "id", "repo"]
         }
     },
     {
         name: "memory-bulk-delete",
+        title: "Memory Bulk Delete",
         description: "Delete multiple memory entries at once.",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: true,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -304,11 +526,30 @@ export const TOOL_DEFINITIONS = [
                 ids: { type: "array", items: { type: "string", format: "uuid" }, minItems: 1, description: "Array of memory IDs to delete" }
             },
             required: ["repo", "ids"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                repo: { type: "string" },
+                deletedCount: { type: "number" },
+                ids: {
+                    type: "array",
+                    items: { type: "string" }
+                }
+            },
+            required: ["success", "repo", "deletedCount", "ids"]
         }
     },
     {
         name: "memory-recap",
+        title: "Memory Recap",
         description: "Get the last 20 memories from a repository for context",
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -328,11 +569,57 @@ export const TOOL_DEFINITIONS = [
                 }
             },
             required: ["repo"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                repo: { type: "string" },
+                count: { type: "number" },
+                total: { type: "number" },
+                offset: { type: "number" },
+                summary: { type: "string" },
+                memories: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            number: { type: "number" },
+                            id: { type: "string" },
+                            type: { type: "string" },
+                            importance: { type: "number" },
+                            preview: { type: "string" },
+                            created_at: { type: "string" }
+                        },
+                        required: ["number", "id", "type", "importance", "preview", "created_at"]
+                    }
+                },
+                tasks: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string" },
+                            task_code: { type: "string" },
+                            title: { type: "string" },
+                            status: { type: "string" },
+                            priority: { type: "number" }
+                        },
+                        required: ["id", "task_code", "title", "status", "priority"]
+                    }
+                }
+            },
+            required: ["repo", "count", "total", "offset", "memories", "tasks", "summary"]
         }
     },
     {
         name: "task-create",
+        title: "Task Create",
         description: "Create a new task in a repository. task_code must be unique within the repository. 'est_tokens' is optional during planning/creation.",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -353,11 +640,31 @@ export const TOOL_DEFINITIONS = [
                 est_tokens: { type: "number", minimum: 0, description: "Estimated tokens budget for this task" }
             },
             required: ["repo", "task_code", "phase", "title", "description", "status"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                id: { type: "string" },
+                repo: { type: "string" },
+                task_code: { type: "string" },
+                phase: { type: "string" },
+                title: { type: "string" },
+                status: { type: "string" },
+                priority: { type: "number" }
+            },
+            required: ["success", "id", "repo", "task_code", "phase", "title", "status", "priority"]
         }
     },
     {
         name: "task-update",
+        title: "Task Update",
         description: "Update an existing task. Provide only the fields that need to be changed. MANDATORY WORKFLOW: You cannot move a task from 'pending' or 'blocked' directly to 'completed'. You MUST move it to 'in_progress' first. When changing status to 'completed', include 'est_tokens' with the estimated total tokens actually used for the task.",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -381,11 +688,33 @@ export const TOOL_DEFINITIONS = [
                 est_tokens: { type: "number", minimum: 0, description: "Estimated total tokens actually used for this task. Required when status changes to 'completed'." }
             },
             required: ["repo", "id"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                id: { type: "string" },
+                repo: { type: "string" },
+                status: { type: "string" },
+                archivedToMemory: { type: "boolean" },
+                updatedFields: {
+                    type: "array",
+                    items: { type: "string" }
+                }
+            },
+            required: ["success", "id", "repo", "status", "archivedToMemory", "updatedFields"]
         }
     },
     {
         name: "task-delete",
+        title: "Task Delete",
         description: "Delete a task from a repository.",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: true,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -393,11 +722,26 @@ export const TOOL_DEFINITIONS = [
                 id: { type: "string", format: "uuid", description: "Task ID" }
             },
             required: ["repo", "id"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                id: { type: "string" },
+                repo: { type: "string" }
+            },
+            required: ["success", "id", "repo"]
         }
     },
     {
         name: "task-list",
-        description: "List tasks for a repository to understand current progress and next steps. MANDATORY: Always call this at the start of a session to sync with other agents.",
+        title: "Task List",
+        description: "List or search tasks for a repository. Use 'search' to filter by code, title, or description. Use 'status' (comma-separated) to filter by status (backlog, pending, in_progress, completed, canceled, blocked). Defaults to active tasks.",
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -407,13 +751,16 @@ export const TOOL_DEFINITIONS = [
                 },
                 status: {
                     type: "string",
-                    enum: ["pending", "in_progress", "completed", "canceled", "blocked"],
-                    description: "Filter by status"
+                    description: "Filter by status (e.g. 'pending,in_progress' or 'completed'). Defaults to active tasks if omitted."
                 },
                 phase: {
                     type: "string",
                     description: "Filter by phase"
                 },
+                search: {
+                    type: "string",
+                    description: "Search query to filter by task code, title, or description"
+                },
                 limit: {
                     type: "number",
                     minimum: 1,
@@ -429,11 +776,113 @@ export const TOOL_DEFINITIONS = [
                 }
             },
             required: ["repo"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                repo: { type: "string" },
+                count: { type: "number" },
+                offset: { type: "number" },
+                limit: { type: "number" },
+                tasks: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string" },
+                            repo: { type: "string" },
+                            task_code: { type: "string" },
+                            phase: { type: "string" },
+                            title: { type: "string" },
+                            description: { type: "string" },
+                            status: { type: "string" },
+                            priority: { type: "number" }
+                        },
+                        required: ["id", "repo", "task_code", "phase", "title", "description", "status", "priority"]
+                    }
+                }
+            },
+            required: ["repo", "count", "offset", "limit", "tasks"]
+        }
+    },
+    {
+        name: "task-search",
+        title: "Task Search",
+        description: "Search for tasks by code, title, or description across any status.",
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        },
+        inputSchema: {
+            type: "object",
+            properties: {
+                repo: {
+                    type: "string",
+                    description: "Repository name"
+                },
+                query: {
+                    type: "string",
+                    description: "Search query"
+                },
+                status: {
+                    type: "string",
+                    description: "Optional status filter (comma-separated). Defaults to 'all' if omitted."
+                },
+                limit: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 100,
+                    default: 15,
+                    description: "Maximum number of tasks to return"
+                },
+                offset: {
+                    type: "number",
+                    minimum: 0,
+                    default: 0,
+                    description: "Offset for pagination"
+                }
+            },
+            required: ["repo", "query"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                repo: { type: "string" },
+                count: { type: "number" },
+                offset: { type: "number" },
+                limit: { type: "number" },
+                tasks: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "string" },
+                            repo: { type: "string" },
+                            task_code: { type: "string" },
+                            phase: { type: "string" },
+                            title: { type: "string" },
+                            description: { type: "string" },
+                            status: { type: "string" },
+                            priority: { type: "number" }
+                        },
+                        required: ["id", "repo", "task_code", "phase", "title", "description", "status", "priority"]
+                    }
+                }
+            },
+            required: ["repo", "count", "offset", "limit", "tasks"]
         }
     },
     {
         name: "task-bulk-manage",
+        title: "Task Bulk Manage",
         description: "Perform bulk operations on tasks (e.g., bulk creation, bulk deletion). For bulk_create, 'est_tokens' is optional and can be filled later when the task is completed.",
+        annotations: {
+            readOnlyHint: false,
+            idempotentHint: false,
+            destructiveHint: false,
+            openWorldHint: false
+        },
         inputSchema: {
             type: "object",
             properties: {
@@ -478,6 +927,25 @@ export const TOOL_DEFINITIONS = [
                 }
             },
             required: ["action", "repo"]
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean" },
+                action: { type: "string" },
+                repo: { type: "string" },
+                createdCount: { type: "number" },
+                deletedCount: { type: "number" },
+                taskCodes: {
+                    type: "array",
+                    items: { type: "string" }
+                },
+                ids: {
+                    type: "array",
+                    items: { type: "string" }
+                }
+            },
+            required: ["success", "action", "repo"]
         }
     }
 ];