claude-queue 1.0.0

package/dist/mcp/index.js

@@ -0,0 +1,509 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/http.ts
+var KANBAN_URL = process.env.KANBAN_SERVER_URL || "http://localhost:3333";
+async function httpGet(url) {
+  const response = await fetch(`${KANBAN_URL}${url}`);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+  }
+  return response.json();
+}
+async function httpPost(url, body) {
+  const response = await fetch(`${KANBAN_URL}${url}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+  }
+  return response.json();
+}
+async function httpPatch(url, body) {
+  const response = await fetch(`${KANBAN_URL}${url}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+  }
+  return response.json();
+}
+
+// src/handlers/watch.ts
+async function handleWatch(args) {
+  const projectId = args?.projectId;
+  const project = await httpGet(`/api/projects/${projectId}?heartbeat=true`);
+  const pausedWarning = project.paused ? `
+
+\u26A0\uFE0F WARNING: This project is currently PAUSED. Claude will not pick up new tasks until resumed. The user can click "Resume" in the task queue UI to allow task processing.` : "";
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Connected to project "${project.name}" (${project.id}).${pausedWarning}
+
+You are now watching this task queue. Follow this loop:
+1. Call queue_get_tasks with status "ready" to find available tasks
+2. If found, call queue_claim_task to start working
+3. Update queue_update_activity periodically as you work
+4. If you need user input, call queue_set_blocked with your question
+5. Call queue_wait_for_reply to wait for user response
+6. When done, call queue_complete_task
+7. Auto-commit changes: git add -A && git commit -m "task: {title}"
+8. Repeat from step 1
+
+If a task is deleted while you're working on it, run: git reset --hard HEAD
+If queue_wait_for_reply returns { deleted: true }, discard changes and pick the next task.`
+      }
+    ]
+  };
+}
+
+// src/handlers/tasks.ts
+async function handleGetTasks(args) {
+  const projectId = args?.projectId;
+  const status = args?.status;
+  const project = await httpGet(`/api/projects/${projectId}?heartbeat=true`);
+  if (project.paused) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            paused: true,
+            message: "Project is paused. Wait for user to resume before picking up new tasks."
+          })
+        }
+      ]
+    };
+  }
+  const url = status ? `/api/tasks/project/${projectId}?status=${status}` : `/api/tasks/project/${projectId}`;
+  const tasks = await httpGet(url);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(tasks, null, 2)
+      }
+    ]
+  };
+}
+async function handleClaimTask(args) {
+  const taskId = args?.taskId;
+  const starting_commit = args?.starting_commit;
+  const task = await httpPost(`/api/tasks/${taskId}/move`, {
+    status: "in_progress",
+    position: 0,
+    starting_commit
+  });
+  const [attachments, masterPrompt, projectPrompt] = await Promise.all([
+    httpGet(`/api/attachments/task/${taskId}`),
+    httpGet(`/api/prompts/master`),
+    httpGet(`/api/prompts/project/${task.project_id}`)
+  ]);
+  const imageAttachments = attachments.filter(
+    (a) => a.mime_type.startsWith("image/")
+  );
+  const content = [];
+  const hasPrompts = masterPrompt || projectPrompt;
+  if (hasPrompts) {
+    const promptParts = [];
+    if (masterPrompt) {
+      promptParts.push(`## Master Instructions
+${masterPrompt.content}`);
+    }
+    if (projectPrompt) {
+      promptParts.push(`## Project Instructions
+${projectPrompt.content}`);
+    }
+    content.push({
+      type: "text",
+      text: `# Custom Instructions
+
+${promptParts.join("\n\n")}`
+    });
+  }
+  content.push({
+    type: "text",
+    text: `Claimed task: "${task.title}" - now in progress (starting commit: ${starting_commit})`
+  });
+  if (imageAttachments.length > 0) {
+    const attachmentPaths = [];
+    for (const attachment of imageAttachments) {
+      const pathData = await httpGet(`/api/attachments/${attachment.id}/path`);
+      attachmentPaths.push(pathData.path);
+    }
+    content.push({
+      type: "text",
+      text: `
+
+This task has ${imageAttachments.length} image attachment(s). Read these files to see the images:
+${attachmentPaths.map((p) => `- ${p}`).join("\n")}`
+    });
+  }
+  return { content };
+}
+async function handleCompleteTask(args) {
+  const taskId = args?.taskId;
+  const task = await httpPost(`/api/tasks/${taskId}/move`, {
+    status: "done",
+    position: 0
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Task "${task.title}" completed and moved to Done!`
+      }
+    ]
+  };
+}
+
+// src/handlers/create-task.ts
+async function handleCreateTask(args) {
+  const { projectId, title, description, status = "ready" } = args;
+  const task = await httpPost(`/api/tasks/project/${projectId}`, {
+    title,
+    description: description || null,
+    status
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Created task "${task.title}" in ${status} column (id: ${task.id})`
+      }
+    ]
+  };
+}
+
+// src/handlers/activity.ts
+async function handleUpdateActivity(args) {
+  const taskId = args?.taskId;
+  const activity = args?.activity;
+  await httpPatch(`/api/tasks/${taskId}`, { current_activity: activity });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Activity updated: ${activity}`
+      }
+    ]
+  };
+}
+
+// src/handlers/blocking.ts
+async function handleSetBlocked(args) {
+  const taskId = args?.taskId;
+  const question = args?.question;
+  await httpPatch(`/api/tasks/${taskId}`, {
+    blocked: true,
+    current_activity: "Waiting for user input"
+  });
+  await httpPost(`/api/comments/task/${taskId}`, {
+    author: "claude",
+    content: question
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: "Task marked as blocked. Question posted to user."
+      }
+    ]
+  };
+}
+async function handleWaitForReply(args) {
+  const taskId = args?.taskId;
+  try {
+    const response = await fetch(`${KANBAN_URL}/api/comments/task/${taskId}/wait-for-reply`);
+    if (response.status === 404) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ deleted: true })
+          }
+        ]
+      };
+    }
+    const data = await response.json();
+    if (data.deleted) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ deleted: true })
+          }
+        ]
+      };
+    }
+    if (data.timeout) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ timeout: true })
+          }
+        ]
+      };
+    }
+    await httpPatch(`/api/tasks/${taskId}`, { blocked: false });
+    await httpPatch(`/api/comments/task/${taskId}/mark-seen`, {});
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ reply: data.content })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: String(error) })
+        }
+      ]
+    };
+  }
+}
+
+// src/handlers/comments.ts
+async function handleCheckComments(args) {
+  const taskId = args?.taskId;
+  const since = args?.since;
+  const url = since ? `/api/comments/task/${taskId}?since=${encodeURIComponent(since)}` : `/api/comments/task/${taskId}`;
+  const comments = await httpGet(url);
+  const userComments = comments.filter((c) => c.author === "user");
+  const unseenComments = userComments.filter((c) => !c.seen);
+  if (unseenComments.length > 0) {
+    await httpPatch(`/api/comments/task/${taskId}/mark-seen`, {});
+    await httpPatch(`/api/tasks/${taskId}`, { blocked: false });
+  }
+  if (userComments.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ comments: [], hasNewComments: false })
+        }
+      ]
+    };
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          comments: userComments,
+          hasNewComments: unseenComments.length > 0,
+          latestTimestamp: userComments[userComments.length - 1].created_at
+        })
+      }
+    ]
+  };
+}
+async function handleAddComment(args) {
+  const taskId = args?.taskId;
+  const content = args?.content;
+  await httpPost(`/api/comments/task/${taskId}`, {
+    author: "claude",
+    content
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: "Comment added"
+      }
+    ]
+  };
+}
+
+// src/handlers/list-projects.ts
+async function handleListProjects() {
+  const projects = await httpGet("/api/projects");
+  if (projects.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No projects found. Create a project first by running `claude-queue` in a directory."
+        }
+      ]
+    };
+  }
+  const projectList = projects.map((p) => `  /queue ${p.id}  # ${p.name} (${p.path})`).join("\n");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Available projects:
+
+${projectList}
+
+Run one of the commands above to start working on that project's queue.`
+      }
+    ]
+  };
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "claude-queue",
+  version: "1.0.0"
+});
+server.registerTool(
+  "queue_watch",
+  {
+    description: "Connect to a kanban board and start watching for tasks. Returns instructions for the watching loop.",
+    inputSchema: {
+      projectId: z.string().describe("Project ID (e.g., kbn-a3x9)")
+    }
+  },
+  async (args) => {
+    return await handleWatch(args);
+  }
+);
+server.registerTool(
+  "queue_get_tasks",
+  {
+    description: "Get tasks from the board, optionally filtered by status",
+    inputSchema: {
+      projectId: z.string().describe("Project ID"),
+      status: z.enum(["backlog", "ready", "in_progress", "done"]).optional().describe("Filter by status (optional)")
+    }
+  },
+  async (args) => {
+    return await handleGetTasks(args);
+  }
+);
+server.registerTool(
+  "queue_claim_task",
+  {
+    description: "Claim a ready task and move it to in_progress. Pass the current git commit hash as starting_commit - this will be used to reset changes if the task is cancelled.",
+    inputSchema: {
+      taskId: z.string().describe("Task ID to claim"),
+      starting_commit: z.string().describe("Current git commit hash (from `git rev-parse HEAD`). Used to reset changes if task is cancelled.")
+    }
+  },
+  async (args) => {
+    return await handleClaimTask(args);
+  }
+);
+server.registerTool(
+  "queue_create_task",
+  {
+    description: "Create a new task in a project. Used during planning mode to add tasks to the queue.",
+    inputSchema: {
+      projectId: z.string().describe("Project ID (e.g., kbn-a3x9)"),
+      title: z.string().describe("Task title"),
+      description: z.string().optional().describe("Task description (optional)"),
+      status: z.enum(["backlog", "ready"]).optional().describe("Task status: 'backlog' or 'ready' (default: 'ready')")
+    }
+  },
+  async (args) => {
+    return await handleCreateTask(args);
+  }
+);
+server.registerTool(
+  "queue_update_activity",
+  {
+    description: "Update what you're currently doing on a task",
+    inputSchema: {
+      taskId: z.string().describe("Task ID"),
+      activity: z.string().describe("Current activity (e.g., 'Reading auth module')")
+    }
+  },
+  async (args) => {
+    return await handleUpdateActivity(args);
+  }
+);
+server.registerTool(
+  "queue_set_blocked",
+  {
+    description: "Mark task as blocked and ask user a question",
+    inputSchema: {
+      taskId: z.string().describe("Task ID"),
+      question: z.string().describe("Question to ask the user")
+    }
+  },
+  async (args) => {
+    return await handleSetBlocked(args);
+  }
+);
+server.registerTool(
+  "queue_wait_for_reply",
+  {
+    description: "Poll until user replies to your question. Returns { reply: string } or { deleted: true } if task was deleted.",
+    inputSchema: {
+      taskId: z.string().describe("Task ID")
+    }
+  },
+  async (args) => {
+    return await handleWaitForReply(args);
+  }
+);
+server.registerTool(
+  "queue_complete_task",
+  {
+    description: "Mark task as complete and move to done",
+    inputSchema: {
+      taskId: z.string().describe("Task ID")
+    }
+  },
+  async (args) => {
+    return await handleCompleteTask(args);
+  }
+);
+server.registerTool(
+  "queue_check_comments",
+  {
+    description: "Check for new user comments on a task. Call this periodically while working to see if the user has left feedback or instructions.",
+    inputSchema: {
+      taskId: z.string().describe("Task ID"),
+      since: z.string().optional().describe("ISO timestamp to check for comments after (optional). If not provided, returns all user comments.")
+    }
+  },
+  async (args) => {
+    return await handleCheckComments(args);
+  }
+);
+server.registerTool(
+  "queue_add_comment",
+  {
+    description: "Add a comment to a task. Use this to leave summaries or notes.",
+    inputSchema: {
+      taskId: z.string().describe("Task ID"),
+      content: z.string().describe("Comment content")
+    }
+  },
+  async (args) => {
+    return await handleAddComment(args);
+  }
+);
+server.registerTool(
+  "queue_list_projects",
+  {
+    description: "List all available projects. Use this when no project ID is provided or when a project is not found.",
+    inputSchema: {}
+  },
+  async () => {
+    return await handleListProjects();
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch(console.error);

package/dist/mcp.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const mcpPath = join(__dirname, "mcp", "index.js");
+
+import(mcpPath);