@episoda/mcp 0.1.8 → 0.1.10

package/dist/cli.js

@@ -278,7 +278,7 @@ ${task.description_md || "_No description_"}`
         }
       },
       async (args) => {
-        const result = await apiRequest("GET", `/api/modules/${args.module_uid}/tasks`);
+        const result = await apiRequest("GET", `/api/tasks?module_id=${args.module_uid}`);
         if (!result.success || !result.tasks) {
           return { content: [{ type: "text", text: `Error: ${result.error || "Failed to fetch tasks"}` }], isError: true };
         }
@@ -300,6 +300,27 @@ ${taskList}`
         };
       }
     );
+    server.registerTool(
+      "delete_task",
+      {
+        description: "Delete a task by UID",
+        inputSchema: {
+          task_uid: z.string().describe("The UID of the task (e.g., EP584-1)")
+        }
+      },
+      async (args) => {
+        const result = await apiRequest("DELETE", `/api/tasks/${args.task_uid}`);
+        if (!result.success) {
+          return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Task ${args.task_uid} deleted`
+          }]
+        };
+      }
+    );
     server.registerTool(
       "batch_update_task_state",
       {
@@ -629,6 +650,123 @@ ${mod.description_md || "_No description_"}`
         };
       }
     );
+    server.registerTool(
+      "delete_module",
+      {
+        description: "Delete a module by UID",
+        inputSchema: {
+          module_uid: z.string().describe("The UID of the module (e.g., EP584)")
+        }
+      },
+      async (args) => {
+        const result = await apiRequest("DELETE", `/api/modules/${args.module_uid}`);
+        if (!result.success) {
+          return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Module ${args.module_uid} deleted`
+          }]
+        };
+      }
+    );
+    server.registerTool(
+      "list_modules",
+      {
+        description: `List modules in the project with optional filtering.
+
+USE THIS WHEN:
+- Discovering modules without knowing UIDs
+- Checking what's currently in progress
+- Finding modules by state`,
+        inputSchema: {
+          state: z.enum(["backlog", "ready", "doing", "review", "done"]).optional().describe("Filter by module state"),
+          limit: z.number().optional().describe("Maximum results (default: 25)"),
+          include_task_counts: z.boolean().optional().describe("Include task counts per module")
+        }
+      },
+      async (args) => {
+        const params = new URLSearchParams();
+        if (args.state) params.set("state", args.state);
+        if (args.limit) params.set("limit", String(args.limit));
+        if (args.include_task_counts) params.set("includeTaskCounts", "true");
+        const query = params.toString();
+        const result = await apiRequest("GET", `/api/modules${query ? `?${query}` : ""}`);
+        if (!result.success || !result.modules) {
+          return { content: [{ type: "text", text: `Error: ${result.error || "Failed to fetch modules"}` }], isError: true };
+        }
+        if (result.modules.length === 0) {
+          return { content: [{ type: "text", text: `No modules found${args.state ? ` in state "${args.state}"` : ""}.` }] };
+        }
+        const moduleList = result.modules.map((m) => {
+          const taskInfo = m.task_counts ? ` [${m.task_counts.done}/${m.task_counts.total} tasks]` : "";
+          return `- **${m.uid}**: ${m.title} (${m.state})${taskInfo}`;
+        }).join("\n");
+        return {
+          content: [{
+            type: "text",
+            text: `# Modules${args.state ? ` (${args.state})` : ""}
+
+${moduleList}`
+          }]
+        };
+      }
+    );
+    server.registerTool(
+      "transition_module",
+      {
+        description: `Transition a module to a new state using the orchestrated transition API.
+
+This triggers the full transition flow (e.g., doing\u2192review creates PR, review\u2192done triggers merge).
+Use this instead of request_review or mark_done for full control.`,
+        inputSchema: {
+          module_uid: z.string().describe("The UID of the module (e.g., EP584)"),
+          target_state: z.enum(["ready", "doing", "review", "done"]).describe("Target state for the module")
+        }
+      },
+      async (args) => {
+        const result = await apiRequest(
+          "POST",
+          `/api/modules/${args.module_uid}/transition`,
+          { targetState: args.target_state }
+        );
+        if (!result.success) {
+          return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Module ${args.module_uid} transitioned to ${args.target_state}`
+          }]
+        };
+      }
+    );
+    server.registerTool(
+      "archive_module",
+      {
+        description: "Archive a module instead of deleting it",
+        inputSchema: {
+          module_uid: z.string().describe("The UID of the module (e.g., EP584)")
+        }
+      },
+      async (args) => {
+        const result = await apiRequest(
+          "POST",
+          `/api/modules/${args.module_uid}/archive`,
+          {}
+        );
+        if (!result.success) {
+          return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Module ${args.module_uid} archived`
+          }]
+        };
+      }
+    );
     server.registerTool(
       "get_knowledge",
       {
@@ -973,6 +1111,98 @@ ${list}`
         };
       }
     );
+    server.registerTool(
+      "create_knowledge",
+      {
+        description: `Create a new knowledge document in the knowledge base.
+
+USE THIS WHEN:
+- Documenting technical decisions or architecture
+- Capturing research findings or discoveries
+- Creating process directives or guidelines
+
+All documentation MUST be created in the knowledge base, not as markdown files.`,
+        inputSchema: {
+          title: z.string().describe("Title of the knowledge document"),
+          domain: z.enum(["tech", "business", "process", "people"]).describe("Knowledge domain"),
+          doc_type: z.enum(["directive", "discovery", "documentation"]).describe("Document type"),
+          significance: z.number().describe("Significance score from 0.0 to 1.0"),
+          markdown: z.string().describe("The document content in markdown")
+        }
+      },
+      async (args) => {
+        const result = await apiRequest("POST", "/api/knowledge", {
+          title: args.title,
+          domain: args.domain,
+          doc_type: args.doc_type,
+          significance: args.significance,
+          markdown: args.markdown
+        });
+        if (!result.success) {
+          return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
+        }
+        const k = result.knowledge;
+        return {
+          content: [{
+            type: "text",
+            text: `Created knowledge document${k?.uid ? ` ${k.uid}` : ""}: ${k?.title} (id: ${k?.id})`
+          }]
+        };
+      }
+    );
+    server.registerTool(
+      "update_knowledge",
+      {
+        description: "Update an existing knowledge document",
+        inputSchema: {
+          knowledge_id: z.string().describe("The ID of the knowledge document"),
+          title: z.string().optional().describe("New title"),
+          markdown: z.string().optional().describe("New markdown content"),
+          domain: z.enum(["tech", "business", "process", "people"]).optional().describe("New domain"),
+          doc_type: z.enum(["directive", "discovery", "documentation"]).optional().describe("New document type"),
+          significance: z.number().optional().describe("New significance score (0.0-1.0)")
+        }
+      },
+      async (args) => {
+        const updates = {};
+        if (args.title) updates.title = args.title;
+        if (args.markdown) updates.markdown = args.markdown;
+        if (args.domain) updates.domain = args.domain;
+        if (args.doc_type) updates.doc_type = args.doc_type;
+        if (args.significance !== void 0) updates.significance = args.significance;
+        const result = await apiRequest("PATCH", `/api/knowledge/${args.knowledge_id}`, updates);
+        if (!result.success) {
+          return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Knowledge document ${args.knowledge_id} updated`
+          }]
+        };
+      }
+    );
+    server.registerTool(
+      "delete_knowledge",
+      {
+        description: "Delete a knowledge document by ID",
+        inputSchema: {
+          knowledge_id: z.string().describe("The ID of the knowledge document")
+        }
+      },
+      async (args) => {
+        const result = await apiRequest("DELETE", `/api/knowledge/${args.knowledge_id}`);
+        if (!result.success) {
+          return { content: [{ type: "text", text: `Error: ${result.error}` }], isError: true };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Knowledge document ${args.knowledge_id} deleted`
+          }]
+        };
+      }
+    );
     server.registerTool(
       "get_module_context",
       {