@proletariat/cli 0.3.22 → 0.3.24

package/dist/lib/mcp/tools/cli-passthrough.js

@@ -0,0 +1,333 @@
+/**
+ * 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 { z } from 'zod';
+import { errorResponse, textResponse } from '../helpers.js';
+export function registerAgentTools(server, ctx) {
+    server.tool('agent_list', 'List all agents', { type: z.enum(['staff', 'temp', 'all']).optional() }, async (params) => {
+        try {
+            const typeFlag = params.type ? `--type ${params.type}` : '';
+            const output = ctx.runCommand(`prlt agent list ${typeFlag} --json 2>/dev/null || prlt agent list ${typeFlag}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('agent_status', 'Check agent status', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt agent status --json 2>/dev/null || prlt agent status');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('agent_add', 'Add new agents', {
+        names: z.array(z.string()).optional().describe('Agent names'),
+        theme: z.string().optional().describe('Theme for names'),
+        clone: z.boolean().optional().describe('Use git clone instead of worktree'),
+    }, async (params) => {
+        try {
+            const namesArg = params.names?.join(' ') || '';
+            const themeFlag = params.theme ? `--theme ${params.theme}` : '';
+            const cloneFlag = params.clone ? '--clone' : '';
+            const output = ctx.runCommand(`prlt agent staff add ${namesArg} ${themeFlag} ${cloneFlag} --json`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('agent_remove', 'Remove an agent', { name: z.string().describe('Agent name') }, async (params) => {
+        try {
+            const output = ctx.runCommand(`prlt agent remove ${params.name} --json`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}
+export function registerDockerTools(server, ctx) {
+    server.tool('docker_status', 'Check Docker daemon status', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt docker status');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('docker_list', 'List Docker containers', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt docker list');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('docker_start', 'Start Docker containers', { agent: z.string().optional().describe('Agent name') }, async (params) => {
+        try {
+            const agentArg = params.agent || '';
+            const output = ctx.runCommand(`prlt docker start ${agentArg}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('docker_stop', 'Stop Docker containers', { agent: z.string().optional().describe('Agent name') }, async (params) => {
+        try {
+            const agentArg = params.agent || '';
+            const output = ctx.runCommand(`prlt docker stop ${agentArg}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('docker_logs', 'Get container logs', {
+        agent: z.string().describe('Agent name'),
+        lines: z.number().optional().describe('Number of lines'),
+    }, async (params) => {
+        try {
+            const linesFlag = params.lines ? `-n ${params.lines}` : '';
+            const output = ctx.runCommand(`prlt docker logs ${params.agent} ${linesFlag}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}
+export function registerRepoTools(server, ctx) {
+    server.tool('repo_list', 'List repositories in workspace', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt repo list');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('repo_add', 'Add a repository', {
+        path: z.string().describe('Repository path or URL'),
+        name: z.string().optional().describe('Name for the repo'),
+    }, async (params) => {
+        try {
+            const nameFlag = params.name ? `--name ${params.name}` : '';
+            const output = ctx.runCommand(`prlt repo add ${params.path} ${nameFlag}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('repo_remove', 'Remove a repository', { name: z.string().describe('Repository name') }, async (params) => {
+        try {
+            const output = ctx.runCommand(`prlt repo remove ${params.name}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}
+export function registerBranchTools(server, ctx) {
+    server.tool('branch_list', 'List branches', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt branch list');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('branch_create', 'Create a branch for a ticket', {
+        ticket_id: z.string().describe('Ticket ID'),
+        name: z.string().optional().describe('Branch name override'),
+    }, async (params) => {
+        try {
+            const nameFlag = params.name ? `--name ${params.name}` : '';
+            const output = ctx.runCommand(`prlt branch create ${params.ticket_id} ${nameFlag}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('branch_where', 'Show which ticket/branch you are on', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt branch where');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}
+export function registerGitHubTools(server, ctx) {
+    server.tool('gh_status', 'Check GitHub CLI status', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt gh status');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('gh_login', 'Login to GitHub', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt gh login');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('pr_create', 'Create a pull request', {
+        ticket_id: z.string().optional().describe('Ticket ID'),
+        title: z.string().optional().describe('PR title'),
+        body: z.string().optional().describe('PR body'),
+        draft: z.boolean().optional().describe('Create as draft'),
+    }, async (params) => {
+        try {
+            const ticketArg = params.ticket_id || '';
+            const titleFlag = params.title ? `--title "${params.title}"` : '';
+            const bodyFlag = params.body ? `--body "${params.body}"` : '';
+            const draftFlag = params.draft ? '--draft' : '';
+            const output = ctx.runCommand(`prlt pr create ${ticketArg} ${titleFlag} ${bodyFlag} ${draftFlag}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('pr_list', 'List pull requests', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt pr list');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('pr_status', 'Check PR status', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt pr status');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}
+export function registerInitTools(server, ctx) {
+    server.tool('init', 'Initialize an HQ workspace', {
+        name: z.string().describe('HQ name'),
+        path: z.string().optional().describe('HQ path'),
+        repos: z.array(z.string()).optional().describe('Repository paths'),
+        agents: z.array(z.string()).optional().describe('Agent names'),
+        pmo: z.boolean().optional().describe('Include PMO'),
+    }, async (params) => {
+        try {
+            const pathFlag = params.path ? `--path ${params.path}` : '';
+            const reposFlag = params.repos?.length ? `--repos ${params.repos.join(',')}` : '';
+            const agentsFlag = params.agents?.length ? `--agents ${params.agents.join(',')}` : '';
+            const pmoFlag = params.pmo === false ? '--no-pmo' : '--pmo';
+            const output = ctx.runCommand(`prlt init --name ${params.name} ${pathFlag} ${reposFlag} ${agentsFlag} ${pmoFlag} --json`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('pmo_init', 'Initialize PMO in existing workspace', {
+        template: z.string().optional().describe('Board template'),
+        name: z.string().optional().describe('Board name'),
+    }, async (params) => {
+        try {
+            const templateFlag = params.template ? `--template ${params.template}` : '';
+            const nameFlag = params.name ? `--name ${params.name}` : '';
+            const output = ctx.runCommand(`prlt pmo init ${templateFlag} ${nameFlag}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}
+export function registerUtilityTools(server, ctx) {
+    server.tool('whoami', 'Show current context (agent, workspace)', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt whoami');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('commit', 'Create a commit with ticket reference', {
+        message: z.string().describe('Commit message'),
+        ticket_id: z.string().optional().describe('Ticket ID'),
+    }, async (params) => {
+        try {
+            const ticketArg = params.ticket_id || '';
+            const output = ctx.runCommand(`prlt commit "${params.message}" ${ticketArg}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('execution_list', 'List work executions', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt execution list');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('execution_view', 'View execution details', { id: z.string().describe('Execution ID') }, async (params) => {
+        try {
+            const output = ctx.runCommand(`prlt execution view ${params.id}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('execution_logs', 'Get execution logs', { id: z.string().describe('Execution ID') }, async (params) => {
+        try {
+            const output = ctx.runCommand(`prlt execution logs ${params.id}`);
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('session_list', 'List tmux sessions', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt session list');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('config_show', 'Show configuration', {}, async () => {
+        try {
+            const output = ctx.runCommand('prlt config');
+            return textResponse(output);
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

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

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

@@ -0,0 +1,178 @@
+/**
+ * MCP Epic Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerEpicTools(server, ctx) {
+    server.tool('epic_list', 'List epics', {
+        project: z.string().optional(),
+        status: z.enum(['active', 'draft', 'complete', 'dropped', 'future']).optional(),
+        search: z.string().optional(),
+    }, 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 epics = await ctx.storage.listEpics(projectId, { status: params.status, search: params.search });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count: epics.length,
+                            epics: epics.map((e) => ({
+                                id: e.id,
+                                title: e.title,
+                                status: e.status,
+                                position: e.position,
+                                projectId: e.projectId,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('epic_create', 'Create an epic', {
+        title: z.string().describe('Epic title'),
+        project: z.string().optional(),
+        description: z.string().optional(),
+        status: z.enum(['active', 'draft', 'complete', 'dropped', 'future']).optional(),
+        spec_id: z.string().optional(),
+    }, 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 epic = await ctx.storage.createEpic(projectId, {
+                title: params.title,
+                description: params.description,
+                status: params.status || 'draft',
+                specId: params.spec_id,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, epic: { id: epic.id, title: epic.title, status: epic.status } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('epic_show', 'Get epic details with tickets', { id: z.string().describe('Epic ID') }, async (params) => {
+        try {
+            const epic = await ctx.storage.getEpic(params.id);
+            if (!epic)
+                throw new Error(`Epic not found: ${params.id}`);
+            const tickets = await ctx.storage.getTicketsForEpic(epic.projectId, params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            epic: {
+                                ...epic,
+                                ticketCount: tickets.length,
+                                tickets: tickets.map((t) => ({ id: t.id, title: t.title, statusName: t.statusName, priority: t.priority })),
+                                createdAt: epic.createdAt.toISOString(),
+                                updatedAt: epic.updatedAt.toISOString(),
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('epic_update', 'Update an epic', {
+        id: z.string().describe('Epic ID'),
+        title: z.string().optional(),
+        description: z.string().optional(),
+        status: z.enum(['active', 'draft', 'complete', 'dropped', 'future']).optional(),
+    }, async (params) => {
+        try {
+            const changes = {};
+            if (params.title)
+                changes.title = params.title;
+            if (params.description !== undefined)
+                changes.description = params.description;
+            if (params.status)
+                changes.status = params.status;
+            const epic = await ctx.storage.updateEpic(params.id, changes);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, epic: { id: epic.id, title: epic.title, status: epic.status } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('epic_delete', 'Delete an epic', { id: z.string().describe('Epic ID') }, async (params) => {
+        try {
+            await ctx.storage.deleteEpic(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: `Deleted epic ${params.id}` }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('epic_reorder', 'Reorder an epic', {
+        id: z.string().describe('Epic ID'),
+        position: z.number().describe('New position'),
+        project: z.string().optional(),
+    }, async (params) => {
+        try {
+            const epic = await ctx.storage.getEpic(params.id);
+            if (!epic)
+                throw new Error(`Epic not found: ${params.id}`);
+            const reordered = await ctx.storage.reorderEpic(params.project || epic.projectId, params.id, params.position);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, epic: { id: reordered.id, position: reordered.position } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('epic_add_blocker', 'Add epic dependency', {
+        epic_id: z.string().describe('Epic that will be blocked'),
+        blocker_id: z.string().describe('Epic that blocks'),
+    }, async (params) => {
+        try {
+            await ctx.storage.createEpicDependency(params.epic_id, params.blocker_id, 'blocks');
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Epic dependency added' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

@@ -0,0 +1,18 @@
+/**
+ * MCP Tools - Export all tool registrars
+ */
+export { registerTicketTools } from './ticket.js';
+export { registerProjectTools } from './project.js';
+export { registerBoardTools } from './board.js';
+export { registerSpecTools } from './spec.js';
+export { registerEpicTools } from './epic.js';
+export { registerWorkTools } from './work.js';
+export { registerWorkflowTools } from './workflow.js';
+export { registerStatusTools } from './status.js';
+export { registerPhaseTools } from './phase.js';
+export { registerActionTools } from './action.js';
+export { registerRoadmapTools } from './roadmap.js';
+export { registerCategoryTools } from './category.js';
+export { registerTemplateTools } from './template.js';
+export { registerViewTools } from './view.js';
+export { registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from './cli-passthrough.js';

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

@@ -0,0 +1,19 @@
+/**
+ * MCP Tools - Export all tool registrars
+ */
+export { registerTicketTools } from './ticket.js';
+export { registerProjectTools } from './project.js';
+export { registerBoardTools } from './board.js';
+export { registerSpecTools } from './spec.js';
+export { registerEpicTools } from './epic.js';
+export { registerWorkTools } from './work.js';
+export { registerWorkflowTools } from './workflow.js';
+export { registerStatusTools } from './status.js';
+export { registerPhaseTools } from './phase.js';
+export { registerActionTools } from './action.js';
+export { registerRoadmapTools } from './roadmap.js';
+export { registerCategoryTools } from './category.js';
+export { registerTemplateTools } from './template.js';
+export { registerViewTools } from './view.js';
+// CLI passthrough tools
+export { registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from './cli-passthrough.js';

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

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