@episoda/mcp 0.1.7 → 0.1.9

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`,
+          { target_state: 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",
       {
@@ -856,6 +994,62 @@ Both semantic and text search returned no results.` }] };
 Query: "${args.query}"
 Found: ${ranked.length} documents (${bothCount} matched both semantic + text)
 
+${list}`
+          }]
+        };
+      }
+    );
+    server.registerTool(
+      "search_conversations",
+      {
+        description: `Search past agent conversations in this project.
+
+This searches agent conversation history (agent_messages) across sessions you can access.
+
+USE THIS WHEN:
+- The user references a prior discussion
+- You need to recover context after compaction
+- You want to find when/where something was decided`,
+        inputSchema: {
+          query: z.string().describe("Semantic search query"),
+          limit: z.number().optional().describe("Max results (default: 10)"),
+          threshold: z.number().optional().describe("Min similarity 0-1 (default: 0.5)"),
+          days_back: z.number().optional().describe("Limit to recent N days (optional)"),
+          session_id: z.string().optional().describe("Limit to a specific session UUID (optional)")
+        }
+      },
+      async (args) => {
+        const result = await apiRequest(
+          "POST",
+          "/api/search/conversations",
+          {
+            query: args.query,
+            limit: args.limit || 10,
+            threshold: args.threshold || 0.5,
+            ...args.days_back !== void 0 ? { days_back: args.days_back } : {},
+            ...args.session_id ? { session_id: args.session_id } : {}
+          }
+        );
+        if (!result.success || !result.results) {
+          return { content: [{ type: "text", text: `Error: ${result.error || "Conversation search failed"}` }], isError: true };
+        }
+        if (result.results.length === 0) {
+          return { content: [{ type: "text", text: `No conversation messages found matching: "${args.query}"` }] };
+        }
+        const list = result.results.map((r) => {
+          const score = Math.round((r.similarity || 0) * 100);
+          const moduleInfo = r.module_uid ? ` | ${r.module_uid}${r.module_title ? `: ${r.module_title}` : ""}` : "";
+          const when = r.created_at ? ` | ${r.created_at}` : "";
+          return `- [${r.role}, ${score}%] ${r.content_snippet}${moduleInfo}${when}`;
+        }).join("\n");
+        return {
+          content: [{
+            type: "text",
+            text: `# Conversation Search Results
+
+Query: "${args.query}"
+Found: ${result.results.length}
+
 ${list}`
           }]
         };
@@ -917,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",
       {