@damper/mcp 0.1.1 → 0.1.3

package/dist/index.js

@@ -21,6 +21,12 @@ async function api(method, path, body) {
     });
     if (!res.ok) {
         const err = await res.json().catch(() => ({}));
+        // Preserve lock info for 409 conflicts
+        if (res.status === 409 && err.lockedBy) {
+            const lockErr = new Error(err.error || `HTTP ${res.status}`);
+            lockErr.lockInfo = err;
+            throw lockErr;
+        }
         throw new Error(err.error || `HTTP ${res.status}`);
     }
     return res.json();
@@ -30,31 +36,94 @@ const server = new McpServer({
     name: 'damper',
     version: '0.1.0',
 });
+// Output schemas
+const TaskSummarySchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    type: z.string(),
+    status: z.string(),
+    priority: z.string(),
+    feedbackCount: z.number(),
+    hasImplementationPlan: z.boolean(),
+});
+const TaskDetailSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    description: z.string().optional(),
+    type: z.string(),
+    implementationPlan: z.string().optional(),
+    status: z.string(),
+    voteScore: z.number(),
+    agentNotes: z.string().optional(),
+    feedback: z.array(z.object({
+        id: z.string(),
+        title: z.string(),
+        description: z.string(),
+        voterCount: z.number(),
+    })),
+});
+const FeedbackSummarySchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    type: z.string(),
+    voterCount: z.number(),
+    linkedTaskId: z.string().optional(),
+});
+const FeedbackDetailSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    description: z.string(),
+    type: z.string(),
+    status: z.string(),
+    voteScore: z.number(),
+    linkedTaskId: z.string().optional(),
+    voters: z.array(z.object({ email: z.string(), plan: z.string() })),
+    comments: z.array(z.object({ author: z.string(), body: z.string() })),
+});
 // Tool: List tasks
 server.registerTool('list_tasks', {
     title: 'List Tasks',
-    description: 'Get roadmap tasks. Returns planned/in-progress by default.',
+    description: 'Get roadmap tasks. Returns planned/in-progress by default. ' +
+        'Filter by type to get bugs, features, etc.',
     inputSchema: z.object({
         status: z.enum(['planned', 'in_progress', 'done', 'all']).optional(),
+        type: z.enum(['bug', 'feature', 'improvement', 'task']).optional().describe('Filter by task type'),
         limit: z.number().optional(),
     }),
-}, async ({ status, limit }) => {
+    outputSchema: z.object({
+        project: z.string(),
+        tasks: z.array(TaskSummarySchema),
+    }),
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ status, type, limit }) => {
     const params = new URLSearchParams();
     if (status)
         params.set('status', status);
+    if (type)
+        params.set('type', type);
     if (limit)
         params.set('limit', String(limit));
     const query = params.toString();
     const data = await api('GET', `/api/agent/tasks${query ? `?${query}` : ''}`);
     if (!data.tasks.length) {
-        return { content: [{ type: 'text', text: `No tasks in "${data.project.name}"` }] };
+        return {
+            content: [{ type: 'text', text: `No tasks in "${data.project.name}"${type ? ` (type: ${type})` : ''}` }],
+            structuredContent: { project: data.project.name, tasks: [] },
+        };
     }
     const lines = data.tasks.map((t) => {
         const p = t.priority === 'high' ? '🔴' : t.priority === 'medium' ? '🟡' : '⚪';
-        return `• ${t.id}: ${t.title} [${t.status}] ${p}${t.hasImplementationPlan ? ' 📋' : ''}`;
+        const typeIcon = t.type === 'bug' ? '🐛' : t.type === 'feature' ? '✨' : t.type === 'improvement' ? '💡' : '📌';
+        return `• ${t.id}: ${typeIcon} ${t.title} [${t.status}] ${p}${t.hasImplementationPlan ? ' 📋' : ''}`;
     });
     return {
         content: [{ type: 'text', text: `Tasks in "${data.project.name}":\n${lines.join('\n')}` }],
+        structuredContent: { project: data.project.name, tasks: data.tasks },
     };
 });
 // Tool: Get task
@@ -64,11 +133,19 @@ server.registerTool('get_task', {
     inputSchema: z.object({
         taskId: z.string().describe('Task ID'),
     }),
+    outputSchema: TaskDetailSchema,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
 }, async ({ taskId }) => {
     const t = await api('GET', `/api/agent/tasks/${taskId}`);
+    const typeIcon = t.type === 'bug' ? '🐛' : t.type === 'feature' ? '✨' : t.type === 'improvement' ? '💡' : '📌';
     const parts = [
-        `# ${t.title}`,
-        `Status: ${t.status} | Score: ${t.voteScore}`,
+        `# ${typeIcon} ${t.title}`,
+        `Type: ${t.type} | Status: ${t.status} | Score: ${t.voteScore}`,
     ];
     if (t.description)
         parts.push(`\n## Description\n${t.description}`);
@@ -80,34 +157,96 @@ server.registerTool('get_task', {
         parts.push(`\n## Feedback (${t.feedback.length})`);
         t.feedback.forEach((f) => parts.push(`- ${f.title} (${f.voterCount} votes)`));
     }
-    return { content: [{ type: 'text', text: parts.join('\n') }] };
+    return {
+        content: [{ type: 'text', text: parts.join('\n') }],
+        structuredContent: t,
+    };
 });
 // Tool: Create task
 server.registerTool('create_task', {
     title: 'Create Task',
-    description: 'Create a new roadmap task. Use for importing from TODO files.',
+    description: 'Create a new roadmap task. Use for importing from TODO files or creating work items.',
     inputSchema: z.object({
         title: z.string(),
         description: z.string().optional(),
+        type: z.enum(['bug', 'feature', 'improvement', 'task']).optional().describe('Task type (default: feature)'),
         status: z.enum(['planned', 'in_progress']).optional(),
         implementationPlan: z.string().optional(),
     }),
+    outputSchema: z.object({
+        id: z.string(),
+        title: z.string(),
+        type: z.string(),
+        status: z.string(),
+    }),
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
 }, async (args) => {
     const result = await api('POST', '/api/agent/tasks', args);
+    const typeIcon = result.type === 'bug' ? '🐛' : result.type === 'feature' ? '✨' : result.type === 'improvement' ? '💡' : '📌';
     return {
-        content: [{ type: 'text', text: `Created: ${result.id} "${result.title}" [${result.status}]` }],
+        content: [{ type: 'text', text: `Created: ${result.id} ${typeIcon} "${result.title}" [${result.status}]` }],
+        structuredContent: result,
     };
 });
 // Tool: Start task
 server.registerTool('start_task', {
     title: 'Start Task',
-    description: 'Mark task as in-progress. Call before working on it.',
+    description: 'Lock and start a task. Fails if locked by another agent unless force=true. ' +
+        'Use force=true to take over a task from another agent (e.g., if they abandoned it).',
     inputSchema: z.object({
         taskId: z.string(),
+        force: z.boolean().optional().describe('Take over lock from another agent'),
     }),
-}, async ({ taskId }) => {
-    const result = await api('POST', `/api/agent/tasks/${taskId}/start`);
-    return { content: [{ type: 'text', text: `Started ${result.id}: ${result.message}` }] };
+    outputSchema: z.object({
+        id: z.string(),
+        status: z.string(),
+        message: z.string(),
+        lockedBy: z.string().optional(),
+        lockedAt: z.string().optional(),
+    }),
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ taskId, force }) => {
+    try {
+        const result = await api('POST', `/api/agent/tasks/${taskId}/start`, force ? { force: true } : undefined);
+        return {
+            content: [{ type: 'text', text: `Started ${result.id}: ${result.message}` }],
+            structuredContent: result,
+        };
+    }
+    catch (err) {
+        const error = err;
+        if (error.lockInfo) {
+            // Return lock info so AI can decide whether to force takeover
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `⚠️ Task is locked by "${error.lockInfo.lockedBy}" since ${error.lockInfo.lockedAt}. ` +
+                            'Use force=true to take over the lock.',
+                    },
+                ],
+                structuredContent: {
+                    id: taskId,
+                    status: 'locked',
+                    message: error.message,
+                    lockedBy: error.lockInfo.lockedBy,
+                    lockedAt: error.lockInfo.lockedAt,
+                },
+                isError: true,
+            };
+        }
+        throw error;
+    }
 });
 // Tool: Add note
 server.registerTool('add_note', {
@@ -117,9 +256,22 @@ server.registerTool('add_note', {
         taskId: z.string(),
         note: z.string(),
     }),
+    outputSchema: z.object({
+        taskId: z.string(),
+        success: z.boolean(),
+    }),
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
 }, async ({ taskId, note }) => {
     await api('POST', `/api/agent/tasks/${taskId}/notes`, { note });
-    return { content: [{ type: 'text', text: `Note added to ${taskId}` }] };
+    return {
+        content: [{ type: 'text', text: `Note added to ${taskId}` }],
+        structuredContent: { taskId, success: true },
+    };
 });
 // Tool: Complete task
 server.registerTool('complete_task', {
@@ -129,9 +281,48 @@ server.registerTool('complete_task', {
         taskId: z.string(),
         summary: z.string().describe('What was implemented'),
     }),
+    outputSchema: z.object({
+        id: z.string(),
+        status: z.string(),
+    }),
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
 }, async ({ taskId, summary }) => {
     const result = await api('POST', `/api/agent/tasks/${taskId}/complete`, { summary });
-    return { content: [{ type: 'text', text: `Completed ${result.id}` }] };
+    return {
+        content: [{ type: 'text', text: `Completed ${result.id}` }],
+        structuredContent: result,
+    };
+});
+// Tool: Abandon task
+server.registerTool('abandon_task', {
+    title: 'Abandon Task',
+    description: 'Release lock and return task to planned status. Use when you cannot complete the task ' +
+        'or need to stop working on it.',
+    inputSchema: z.object({
+        taskId: z.string(),
+    }),
+    outputSchema: z.object({
+        id: z.string(),
+        status: z.string(),
+        message: z.string(),
+    }),
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ taskId }) => {
+    const result = await api('POST', `/api/agent/tasks/${taskId}/abandon`);
+    return {
+        content: [{ type: 'text', text: `Abandoned ${result.id}: ${result.message}` }],
+        structuredContent: result,
+    };
 });
 // Tool: List feedback
 server.registerTool('list_feedback', {
@@ -141,6 +332,15 @@ server.registerTool('list_feedback', {
         status: z.enum(['new', 'under_review', 'planned', 'in_progress', 'done', 'closed']).optional(),
         limit: z.number().optional(),
     }),
+    outputSchema: z.object({
+        feedback: z.array(FeedbackSummarySchema),
+    }),
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
 }, async ({ status, limit }) => {
     const params = new URLSearchParams();
     if (status)
@@ -150,13 +350,19 @@ server.registerTool('list_feedback', {
     const query = params.toString();
     const data = await api('GET', `/api/agent/feedback${query ? `?${query}` : ''}`);
     if (!data.feedback.length) {
-        return { content: [{ type: 'text', text: 'No feedback found' }] };
+        return {
+            content: [{ type: 'text', text: 'No feedback found' }],
+            structuredContent: { feedback: [] },
+        };
     }
     const lines = data.feedback.map((f) => {
         const link = f.linkedTaskId ? ` → ${f.linkedTaskId}` : '';
         return `• ${f.id}: ${f.title} [${f.type}] (${f.voterCount} votes)${link}`;
     });
-    return { content: [{ type: 'text', text: `Feedback:\n${lines.join('\n')}` }] };
+    return {
+        content: [{ type: 'text', text: `Feedback:\n${lines.join('\n')}` }],
+        structuredContent: { feedback: data.feedback },
+    };
 });
 // Tool: Get feedback
 server.registerTool('get_feedback', {
@@ -165,6 +371,13 @@ server.registerTool('get_feedback', {
     inputSchema: z.object({
         feedbackId: z.string(),
     }),
+    outputSchema: FeedbackDetailSchema,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
 }, async ({ feedbackId }) => {
     const f = await api('GET', `/api/agent/feedback/${feedbackId}`);
     const parts = [
@@ -185,7 +398,10 @@ server.registerTool('get_feedback', {
         if (f.comments.length > 3)
             parts.push(`... and ${f.comments.length - 3} more`);
     }
-    return { content: [{ type: 'text', text: parts.join('\n') }] };
+    return {
+        content: [{ type: 'text', text: parts.join('\n') }],
+        structuredContent: f,
+    };
 });
 // Start
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@damper/mcp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "MCP server for Damper task management",
   "author": "Damper <hello@usedamper.com>",
   "repository": {
@@ -15,7 +15,9 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/index.ts",
@@ -33,6 +35,11 @@
   "engines": {
     "node": ">=18"
   },
-  "keywords": ["mcp", "damper", "ai", "task-management"],
+  "keywords": [
+    "mcp",
+    "damper",
+    "ai",
+    "task-management"
+  ],
   "license": "MIT"
 }