@proletariat/cli 0.3.23 → 0.3.25

package/dist/lib/mcp/helpers.js

@@ -0,0 +1,57 @@
+/**
+ * MCP Helper Functions
+ */
+export function formatTicket(t) {
+    return {
+        id: t.id,
+        title: t.title,
+        priority: t.priority,
+        category: t.category,
+        statusName: t.statusName,
+        statusCategory: t.statusCategory,
+        projectId: t.projectId,
+        assignee: t.assignee,
+        owner: t.owner,
+        branch: t.branch,
+        epicId: t.epicId,
+    };
+}
+export function formatTicketFull(t) {
+    return {
+        ...formatTicket(t),
+        description: t.description,
+        subtasks: t.subtasks,
+        labels: t.labels,
+        metadata: t.metadata,
+        blockedBy: t.blockedBy,
+        acceptanceCriteria: t.acceptanceCriteria,
+        specId: t.specId,
+        createdAt: t.createdAt.toISOString(),
+        updatedAt: t.updatedAt.toISOString(),
+    };
+}
+export function successResponse(data) {
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({ success: true, ...data }, null, 2),
+            }],
+    };
+}
+export function errorResponse(error) {
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                }),
+            }],
+        isError: true,
+    };
+}
+export function textResponse(text) {
+    return {
+        content: [{ type: 'text', text }],
+    };
+}

package/dist/lib/mcp/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Library - Main exports
+ */
+export * from './types.js';
+export * from './helpers.js';
+export * from './tools/index.js';

package/dist/lib/mcp/index.js

@@ -0,0 +1,6 @@
+/**
+ * MCP Library - Main exports
+ */
+export * from './types.js';
+export * from './helpers.js';
+export * from './tools/index.js';

package/dist/lib/mcp/tools/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Action Tools
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpToolContext } from '../types.js';
+export declare function registerActionTools(server: McpServer, ctx: McpToolContext): void;

package/dist/lib/mcp/tools/action.js

@@ -0,0 +1,88 @@
+/**
+ * MCP Action Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerActionTools(server, ctx) {
+    server.tool('action_list', 'List work actions', { include_builtin: z.boolean().optional() }, async (params) => {
+        try {
+            const actions = await ctx.storage.listActions({
+                isBuiltin: params.include_builtin ? undefined : false,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            actions: actions.map((a) => ({
+                                id: a.id,
+                                name: a.name,
+                                description: a.description,
+                                modifiesCode: a.modifiesCode,
+                                isBuiltin: a.isBuiltin,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('action_show', 'Get action details', { id: z.string().describe('Action ID') }, async (params) => {
+        try {
+            const action = await ctx.storage.getAction(params.id);
+            if (!action)
+                throw new Error(`Action not found: ${params.id}`);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, action }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('action_create', 'Create a work action', {
+        name: z.string().describe('Action name'),
+        prompt: z.string().describe('Start prompt'),
+        description: z.string().optional(),
+        end_prompt: z.string().optional(),
+        modifies_code: z.boolean().optional(),
+    }, async (params) => {
+        try {
+            const action = await ctx.storage.createAction({
+                name: params.name,
+                prompt: params.prompt,
+                description: params.description,
+                endPrompt: params.end_prompt,
+                modifiesCode: params.modifies_code ?? true,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, action: { id: action.id, name: action.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('action_delete', 'Delete an action', { id: z.string().describe('Action ID') }, async (params) => {
+        try {
+            await ctx.storage.deleteAction(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Action deleted' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

package/dist/lib/mcp/tools/board.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Board Tools
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpToolContext } from '../types.js';
+export declare function registerBoardTools(server: McpServer, ctx: McpToolContext): void;

package/dist/lib/mcp/tools/board.js

@@ -0,0 +1,139 @@
+/**
+ * MCP Board Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerBoardTools(server, ctx) {
+    server.tool('board_show', 'Show the kanban board', { project: z.string().optional().describe('Project ID') }, async (params) => {
+        try {
+            let projectId = params.project;
+            if (!projectId) {
+                const projects = await ctx.storage.listProjects();
+                if (projects.length === 0)
+                    throw new Error('No projects found');
+                projectId = projects[0].id;
+            }
+            const board = await ctx.storage.getBoard(projectId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            board: {
+                                id: board.id,
+                                name: board.name,
+                                columns: board.columns.map((col) => ({
+                                    name: col.name,
+                                    position: col.position,
+                                    ticketCount: col.tickets.length,
+                                    tickets: col.tickets.map((t) => ({
+                                        id: t.id,
+                                        title: t.title,
+                                        priority: t.priority,
+                                        assignee: t.assignee,
+                                    })),
+                                })),
+                                updatedAt: board.updatedAt.toISOString(),
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_columns', 'Get column names for a project', { project: z.string().optional().describe('Project ID') }, async (params) => {
+        try {
+            let projectId = params.project;
+            if (!projectId) {
+                const projects = await ctx.storage.listProjects();
+                if (projects.length === 0)
+                    throw new Error('No projects found');
+                projectId = projects[0].id;
+            }
+            const columns = ctx.storage.getColumnNames(projectId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, projectId, columns }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_create_column', 'Add a new column to the board', {
+        project: z.string().describe('Project ID'),
+        name: z.string().describe('Column name'),
+        position: z.number().optional().describe('Position'),
+    }, async (params) => {
+        try {
+            const column = await ctx.storage.createColumn(params.project, params.name, params.position);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, column: { id: column.id, name: column.name, position: column.position } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_rename_column', 'Rename a column', {
+        project: z.string().describe('Project ID'),
+        column_id: z.string().describe('Column ID'),
+        name: z.string().describe('New name'),
+    }, async (params) => {
+        try {
+            const column = await ctx.storage.renameColumn(params.project, params.column_id, params.name);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, column: { id: column.id, name: column.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_move_column', 'Reorder a column', {
+        project: z.string().describe('Project ID'),
+        column_id: z.string().describe('Column ID'),
+        position: z.number().describe('New position'),
+    }, async (params) => {
+        try {
+            const column = await ctx.storage.moveColumn(params.project, params.column_id, params.position);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, column: { id: column.id, name: column.name, position: column.position } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('board_delete_column', 'Delete a column', {
+        project: z.string().describe('Project ID'),
+        column_id: z.string().describe('Column ID'),
+        cascade: z.boolean().optional().describe('Delete tickets in column'),
+    }, async (params) => {
+        try {
+            await ctx.storage.deleteColumn(params.project, params.column_id, params.cascade);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Column deleted' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

package/dist/lib/mcp/tools/category.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Category Tools
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpToolContext } from '../types.js';
+export declare function registerCategoryTools(server: McpServer, ctx: McpToolContext): void;

package/dist/lib/mcp/tools/category.js

@@ -0,0 +1,84 @@
+/**
+ * MCP Category Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerCategoryTools(server, ctx) {
+    server.tool('category_list', 'List categories', { type: z.enum(['ticket', 'status']).optional() }, async (params) => {
+        try {
+            const categories = await ctx.storage.listCategories({ type: params.type });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            categories: categories.map((c) => ({
+                                id: c.id,
+                                name: c.name,
+                                type: c.type,
+                                isBuiltin: c.isBuiltin,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('category_create', 'Create a category', {
+        name: z.string().describe('Category name'),
+        type: z.enum(['ticket', 'status']).describe('Category type'),
+        description: z.string().optional(),
+        color: z.string().optional(),
+    }, async (params) => {
+        try {
+            const category = await ctx.storage.createCategory({
+                name: params.name,
+                type: params.type,
+                description: params.description,
+                color: params.color,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, category: { id: category.id, name: category.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('category_rename', 'Rename a category', {
+        id: z.string().describe('Category ID'),
+        name: z.string().describe('New name'),
+    }, async (params) => {
+        try {
+            const category = await ctx.storage.renameCategory(params.id, params.name);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, category: { id: category.id, name: category.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('category_delete', 'Delete a category', { id: z.string().describe('Category ID') }, async (params) => {
+        try {
+            await ctx.storage.deleteCategory(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Category deleted' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

package/dist/lib/mcp/tools/cli-passthrough.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP CLI Passthrough Tools
+ *
+ * These tools call CLI commands that don't have a clean storage API.
+ * They're wrapped for MCP but return formatted text output.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpToolContext } from '../types.js';
+export declare function registerAgentTools(server: McpServer, ctx: McpToolContext): void;
+export declare function registerDockerTools(server: McpServer, ctx: McpToolContext): void;
+export declare function registerRepoTools(server: McpServer, ctx: McpToolContext): void;
+export declare function registerBranchTools(server: McpServer, ctx: McpToolContext): void;
+export declare function registerGitHubTools(server: McpServer, ctx: McpToolContext): void;
+export declare function registerInitTools(server: McpServer, ctx: McpToolContext): void;
+export declare function registerUtilityTools(server: McpServer, ctx: McpToolContext): void;