@proletariat/cli 0.3.22 → 0.3.24

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

@@ -0,0 +1,131 @@
+/**
+ * MCP Phase Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerPhaseTools(server, ctx) {
+    server.tool('phase_list', 'List project phases', { category: z.enum(['triage', 'backlog', 'unstarted', 'started', 'completed', 'canceled']).optional() }, async (params) => {
+        try {
+            const phases = await ctx.storage.listPhases({ category: params.category });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            phases: phases.map((p) => ({
+                                id: p.id,
+                                name: p.name,
+                                category: p.category,
+                                position: p.position,
+                                isDefault: p.isDefault,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('phase_create', 'Create a project phase', {
+        name: z.string().describe('Phase name'),
+        category: z.enum(['triage', 'backlog', 'unstarted', 'started', 'completed', 'canceled']),
+        position: z.number().optional(),
+        is_default: z.boolean().optional(),
+    }, async (params) => {
+        try {
+            const phase = await ctx.storage.createPhase({
+                name: params.name,
+                category: params.category,
+                position: params.position,
+                isDefault: params.is_default,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, phase: { id: phase.id, name: phase.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('phase_update', 'Update a phase', {
+        id: z.string().describe('Phase ID'),
+        name: z.string().optional(),
+        category: z.enum(['triage', 'backlog', 'unstarted', 'started', 'completed', 'canceled']).optional(),
+    }, async (params) => {
+        try {
+            const changes = {};
+            if (params.name)
+                changes.name = params.name;
+            if (params.category)
+                changes.category = params.category;
+            const phase = await ctx.storage.updatePhase(params.id, changes);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, phase: { id: phase.id, name: phase.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('phase_delete', 'Delete a phase', { id: z.string().describe('Phase ID') }, async (params) => {
+        try {
+            await ctx.storage.deletePhase(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Phase deleted' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('phase_template_list', 'List phase templates', {}, async () => {
+        try {
+            const templates = await ctx.storage.listPhaseTemplates();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            templates: templates.map((t) => ({
+                                id: t.id,
+                                name: t.name,
+                                description: t.description,
+                                isBuiltin: t.isBuiltin,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('phase_template_apply', 'Apply a phase template', { template_id: z.string().describe('Template ID') }, async (params) => {
+        try {
+            const phases = await ctx.storage.applyPhaseTemplate(params.template_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Applied template, created ${phases.length} phases`,
+                            phases: phases.map((p) => ({ id: p.id, name: p.name })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

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

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

@@ -0,0 +1,196 @@
+/**
+ * MCP Project Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerProjectTools(server, ctx) {
+    server.tool('project_list', 'List all projects', {
+        include_archived: z.boolean().optional().describe('Include archived'),
+        search: z.string().optional().describe('Search in name'),
+    }, async (params) => {
+        try {
+            const projects = await ctx.storage.listProjects({
+                isArchived: params.include_archived ? undefined : false,
+                search: params.search,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count: projects.length,
+                            projects: projects.map((p) => ({
+                                id: p.id,
+                                name: p.name,
+                                description: p.description,
+                                template: p.template,
+                                status: p.status,
+                                isArchived: p.isArchived,
+                                workflowId: p.workflowId,
+                                createdAt: p.createdAt.toISOString(),
+                                updatedAt: p.updatedAt.toISOString(),
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('project_create', 'Create a new project', {
+        name: z.string().describe('Project name'),
+        description: z.string().optional().describe('Description'),
+        template: z.string().optional().describe('Template (kanban, scrum, linear, simple)'),
+    }, async (params) => {
+        try {
+            const board = await ctx.storage.createProject({
+                name: params.name,
+                description: params.description,
+                template: params.template,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            project: { id: board.id, name: board.name, columns: board.columns.map((c) => c.name) },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('project_show', 'Get project details', { id: z.string().describe('Project ID') }, async (params) => {
+        try {
+            const project = await ctx.storage.getProject(params.id);
+            if (!project)
+                throw new Error(`Project not found: ${params.id}`);
+            const tickets = await ctx.storage.listTickets(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            project: {
+                                id: project.id,
+                                name: project.name,
+                                description: project.description,
+                                template: project.template,
+                                status: project.status,
+                                isArchived: project.isArchived,
+                                workflowId: project.workflowId,
+                                ticketCount: tickets.length,
+                                createdAt: project.createdAt.toISOString(),
+                                updatedAt: project.updatedAt.toISOString(),
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('project_update', 'Update a project', {
+        id: z.string().describe('Project ID'),
+        name: z.string().optional().describe('New name'),
+        description: z.string().optional().describe('New description'),
+    }, async (params) => {
+        try {
+            const changes = {};
+            if (params.name)
+                changes.name = params.name;
+            if (params.description !== undefined)
+                changes.description = params.description;
+            const project = await ctx.storage.updateProject(params.id, changes);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, project: { id: project.id, name: project.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('project_archive', 'Archive a project', { id: z.string().describe('Project ID') }, async (params) => {
+        try {
+            const project = await ctx.storage.archiveProject(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, project: { id: project.id, isArchived: project.isArchived } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('project_unarchive', 'Unarchive a project', { id: z.string().describe('Project ID') }, async (params) => {
+        try {
+            const project = await ctx.storage.unarchiveProject(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, project: { id: project.id, isArchived: project.isArchived } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('project_delete', 'Delete a project', { id: z.string().describe('Project ID') }, async (params) => {
+        try {
+            await ctx.storage.deleteProject(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: `Deleted project ${params.id}` }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('project_link_to_spec', 'Link project to a spec', {
+        project_id: z.string().describe('Project ID'),
+        spec_id: z.string().describe('Spec ID'),
+    }, async (params) => {
+        try {
+            await ctx.storage.linkProjectToSpec(params.project_id, params.spec_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Project linked to spec' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('project_get_specs', 'Get specs linked to a project', { project_id: z.string().describe('Project ID') }, async (params) => {
+        try {
+            const specs = await ctx.storage.getSpecsForProject(params.project_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            specs: specs.map((s) => ({ id: s.id, title: s.title, status: s.status })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

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

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

@@ -0,0 +1,123 @@
+/**
+ * MCP Roadmap Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerRoadmapTools(server, ctx) {
+    server.tool('roadmap_list', 'List roadmaps', {}, async () => {
+        try {
+            const roadmaps = await ctx.storage.listRoadmaps();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            roadmaps: roadmaps.map((r) => ({
+                                id: r.id,
+                                name: r.name,
+                                description: r.description,
+                                isDefault: r.isDefault,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('roadmap_create', 'Create a roadmap', {
+        name: z.string().describe('Roadmap name'),
+        description: z.string().optional(),
+        is_default: z.boolean().optional(),
+    }, async (params) => {
+        try {
+            const roadmap = await ctx.storage.createRoadmap({
+                name: params.name,
+                description: params.description,
+                isDefault: params.is_default ?? false,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, roadmap: { id: roadmap.id, name: roadmap.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('roadmap_show', 'Get roadmap with projects', { id: z.string().describe('Roadmap ID') }, async (params) => {
+        try {
+            const roadmap = await ctx.storage.getRoadmap(params.id);
+            if (!roadmap)
+                throw new Error(`Roadmap not found: ${params.id}`);
+            const projects = await ctx.storage.listRoadmapProjects(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            roadmap: {
+                                ...roadmap,
+                                projects: projects.map((p) => ({ id: p.id, name: p.name })),
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('roadmap_add_project', 'Add project to roadmap', {
+        roadmap_id: z.string().describe('Roadmap ID'),
+        project_id: z.string().describe('Project ID'),
+        position: z.number().optional(),
+    }, async (params) => {
+        try {
+            await ctx.storage.addProjectToRoadmap(params.roadmap_id, params.project_id, params.position);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Project added to roadmap' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('roadmap_remove_project', 'Remove project from roadmap', {
+        roadmap_id: z.string().describe('Roadmap ID'),
+        project_id: z.string().describe('Project ID'),
+    }, async (params) => {
+        try {
+            await ctx.storage.removeProjectFromRoadmap(params.roadmap_id, params.project_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Project removed from roadmap' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('roadmap_delete', 'Delete a roadmap', { id: z.string().describe('Roadmap ID') }, async (params) => {
+        try {
+            await ctx.storage.deleteRoadmap(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Roadmap deleted' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

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

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

@@ -0,0 +1,196 @@
+/**
+ * MCP Spec Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerSpecTools(server, ctx) {
+    server.tool('spec_list', 'List specifications', {
+        status: z.enum(['draft', 'active', 'implemented']).optional(),
+        type: z.enum(['product', 'platform', 'infra', 'integration']).optional(),
+        search: z.string().optional(),
+    }, async (params) => {
+        try {
+            const specs = await ctx.storage.listSpecs({
+                status: params.status,
+                type: params.type,
+                search: params.search,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count: specs.length,
+                            specs: specs.map((s) => ({
+                                id: s.id,
+                                title: s.title,
+                                status: s.status,
+                                type: s.type,
+                                tags: s.tags,
+                                createdAt: s.createdAt.toISOString(),
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('spec_create', 'Create a specification', {
+        title: z.string().describe('Spec title'),
+        status: z.enum(['draft', 'active', 'implemented']).optional(),
+        type: z.enum(['product', 'platform', 'infra', 'integration']).optional(),
+        problem: z.string().optional(),
+        solution: z.string().optional(),
+        acceptance_criteria: z.string().optional(),
+        context: z.string().optional(),
+    }, async (params) => {
+        try {
+            const spec = await ctx.storage.createSpec({
+                title: params.title,
+                status: params.status || 'draft',
+                type: params.type,
+                problem: params.problem,
+                solution: params.solution,
+                acceptanceCriteria: params.acceptance_criteria,
+                context: params.context,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, spec: { id: spec.id, title: spec.title, status: spec.status } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('spec_show', 'Get spec details', { id: z.string().describe('Spec ID') }, async (params) => {
+        try {
+            const spec = await ctx.storage.getSpec(params.id);
+            if (!spec)
+                throw new Error(`Spec not found: ${params.id}`);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, spec }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('spec_update', 'Update a spec', {
+        id: z.string().describe('Spec ID'),
+        title: z.string().optional(),
+        status: z.enum(['draft', 'active', 'implemented']).optional(),
+        type: z.enum(['product', 'platform', 'infra', 'integration']).optional(),
+        problem: z.string().optional(),
+        solution: z.string().optional(),
+        acceptance_criteria: z.string().optional(),
+    }, async (params) => {
+        try {
+            const changes = {};
+            if (params.title)
+                changes.title = params.title;
+            if (params.status)
+                changes.status = params.status;
+            if (params.type)
+                changes.type = params.type;
+            if (params.problem !== undefined)
+                changes.problem = params.problem;
+            if (params.solution !== undefined)
+                changes.solution = params.solution;
+            if (params.acceptance_criteria !== undefined)
+                changes.acceptanceCriteria = params.acceptance_criteria;
+            const spec = await ctx.storage.updateSpec(params.id, changes);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, spec: { id: spec.id, title: spec.title } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('spec_delete', 'Delete a spec', { id: z.string().describe('Spec ID') }, async (params) => {
+        try {
+            await ctx.storage.deleteSpec(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: `Deleted spec ${params.id}` }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('spec_add_dependency', 'Add spec dependency', {
+        spec_id: z.string().describe('Spec ID'),
+        depends_on_id: z.string().describe('ID of spec this depends on'),
+    }, async (params) => {
+        try {
+            await ctx.storage.addSpecDependency(params.spec_id, params.depends_on_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Dependency added' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('spec_get_dependencies', 'Get spec dependencies', { spec_id: z.string().describe('Spec ID') }, async (params) => {
+        try {
+            const deps = await ctx.storage.getSpecDependencies(params.spec_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            dependencies: deps.map((s) => ({ id: s.id, title: s.title })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('spec_get_tickets', 'Get tickets linked to a spec', {
+        spec_id: z.string().describe('Spec ID'),
+        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');
+                projectId = projects[0].id;
+            }
+            const tickets = await ctx.storage.getTicketsForSpec(projectId, params.spec_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            tickets: tickets.map((t) => ({ id: t.id, title: t.title, statusName: t.statusName })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

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