@proletariat/cli 0.3.23 → 0.3.25

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

@@ -0,0 +1,76 @@
+/**
+ * MCP View Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerViewTools(server, ctx) {
+    server.tool('view_list', 'List board views for a project', { project: z.string().optional() }, async (params) => {
+        try {
+            const views = await ctx.storage.listBoardViews({ projectId: params.project });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            views: views.map((v) => ({
+                                id: v.id,
+                                name: v.name,
+                                description: v.description,
+                                projectId: v.projectId,
+                                isDefault: v.isDefault,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('view_create', 'Create a board view', {
+        project: z.string().describe('Project ID'),
+        name: z.string().describe('View name'),
+        description: z.string().optional(),
+        filters: z.object({
+            assignee: z.string().optional(),
+            owner: z.string().optional(),
+            priority: z.string().optional(),
+            epicId: z.string().optional(),
+            search: z.string().optional(),
+        }).optional(),
+        is_default: z.boolean().optional(),
+    }, async (params) => {
+        try {
+            const view = await ctx.storage.createBoardView({
+                projectId: params.project,
+                name: params.name,
+                description: params.description,
+                filters: params.filters || {},
+                isDefault: params.is_default,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, view: { id: view.id, name: view.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('view_delete', 'Delete a board view', { id: z.string().describe('View ID') }, async (params) => {
+        try {
+            await ctx.storage.deleteBoardView(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'View deleted' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

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

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

@@ -0,0 +1,132 @@
+/**
+ * MCP Work Tools (Agent workflow)
+ */
+import { z } from 'zod';
+import { formatTicket, errorResponse } from '../helpers.js';
+export function registerWorkTools(server, ctx) {
+    server.tool('work_status', 'Get current work status (in-progress tickets)', {}, async () => {
+        try {
+            const tickets = await ctx.storage.listTickets(undefined, { allProjects: true });
+            const inProgress = tickets.filter((t) => t.statusCategory === 'started' && t.assignee);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            inProgressCount: inProgress.length,
+                            tickets: inProgress.map((t) => ({
+                                id: t.id,
+                                title: t.title,
+                                assignee: t.assignee,
+                                statusName: t.statusName,
+                                priority: t.priority,
+                                projectId: t.projectId,
+                                branch: t.branch,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('work_start', 'Start working on a ticket (moves to In Progress)', {
+        ticket_id: z.string().describe('Ticket ID'),
+        assignee: z.string().optional().describe('Who is working'),
+    }, async (params) => {
+        try {
+            const ticket = await ctx.storage.getTicket(params.ticket_id);
+            if (!ticket)
+                throw new Error(`Ticket not found: ${params.ticket_id}`);
+            if (params.assignee) {
+                await ctx.storage.updateTicket(params.ticket_id, { assignee: params.assignee });
+            }
+            const columns = ctx.storage.getColumnNames(ticket.projectId);
+            const progressCol = columns.find((c) => c.toLowerCase().includes('progress') || c.toLowerCase().includes('doing')) || columns[Math.min(1, columns.length - 1)];
+            const moved = await ctx.storage.moveTicket(ticket.projectId, params.ticket_id, progressCol);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            ticket: formatTicket(moved),
+                            message: `Started ${moved.id}: ${moved.title}`,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('work_complete', 'Mark ticket complete (moves to Done)', { ticket_id: z.string().describe('Ticket ID') }, async (params) => {
+        try {
+            const ticket = await ctx.storage.getTicket(params.ticket_id);
+            if (!ticket)
+                throw new Error(`Ticket not found: ${params.ticket_id}`);
+            const columns = ctx.storage.getColumnNames(ticket.projectId);
+            const doneCol = columns.find((c) => c.toLowerCase().includes('done') || c.toLowerCase().includes('complete')) || columns[columns.length - 1];
+            const moved = await ctx.storage.moveTicket(ticket.projectId, params.ticket_id, doneCol);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            ticket: formatTicket(moved),
+                            message: `Completed ${moved.id}`,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('work_ready', 'Mark ticket ready for review', { ticket_id: z.string().describe('Ticket ID') }, async (params) => {
+        try {
+            const ticket = await ctx.storage.getTicket(params.ticket_id);
+            if (!ticket)
+                throw new Error(`Ticket not found: ${params.ticket_id}`);
+            const columns = ctx.storage.getColumnNames(ticket.projectId);
+            const reviewCol = columns.find((c) => c.toLowerCase().includes('review'));
+            if (reviewCol) {
+                const moved = await ctx.storage.moveTicket(ticket.projectId, params.ticket_id, reviewCol);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, ticket: formatTicket(moved), message: `${moved.id} ready for review` }, null, 2),
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'No review column found', ticket: formatTicket(ticket) }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('work_revise', 'Send ticket back for revision', { ticket_id: z.string().describe('Ticket ID') }, async (params) => {
+        try {
+            const ticket = await ctx.storage.getTicket(params.ticket_id);
+            if (!ticket)
+                throw new Error(`Ticket not found: ${params.ticket_id}`);
+            const columns = ctx.storage.getColumnNames(ticket.projectId);
+            const progressCol = columns.find((c) => c.toLowerCase().includes('progress')) || columns[1];
+            const moved = await ctx.storage.moveTicket(ticket.projectId, params.ticket_id, progressCol);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, ticket: formatTicket(moved), message: `${moved.id} sent back for revision` }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

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

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

@@ -0,0 +1,95 @@
+/**
+ * MCP Workflow Tools
+ */
+import { z } from 'zod';
+import { errorResponse } from '../helpers.js';
+export function registerWorkflowTools(server, ctx) {
+    server.tool('workflow_list', 'List all workflows', { include_builtin: z.boolean().optional() }, async (params) => {
+        try {
+            const workflows = await ctx.storage.listWorkflows({
+                isBuiltin: params.include_builtin ? undefined : false,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            workflows: workflows.map((w) => ({
+                                id: w.id,
+                                name: w.name,
+                                description: w.description,
+                                isBuiltin: w.isBuiltin,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('workflow_show', 'Get workflow details with statuses', { id: z.string().describe('Workflow ID') }, async (params) => {
+        try {
+            const workflow = await ctx.storage.getWorkflow(params.id);
+            if (!workflow)
+                throw new Error(`Workflow not found: ${params.id}`);
+            const statuses = await ctx.storage.listStatuses(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            workflow: {
+                                ...workflow,
+                                statuses: statuses.map((s) => ({
+                                    id: s.id,
+                                    name: s.name,
+                                    category: s.category,
+                                    position: s.position,
+                                    isDefault: s.isDefault,
+                                })),
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('workflow_create', 'Create a new workflow', {
+        name: z.string().describe('Workflow name'),
+        description: z.string().optional(),
+        statuses: z.array(z.string()).optional().describe('Status names'),
+    }, async (params) => {
+        try {
+            const workflow = await ctx.storage.createWorkflow({
+                name: params.name,
+                description: params.description,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, workflow: { id: workflow.id, name: workflow.name } }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    server.tool('workflow_delete', 'Delete a workflow', { id: z.string().describe('Workflow ID') }, async (params) => {
+        try {
+            await ctx.storage.deleteWorkflow(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: `Deleted workflow ${params.id}` }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

@@ -0,0 +1,17 @@
+/**
+ * MCP Types and Interfaces
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SQLiteStorage } from '../pmo/storage/index.js';
+export interface McpToolContext {
+    storage: SQLiteStorage;
+    runCommand: (cmd: string) => string;
+}
+export type McpToolResult = {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export type ToolRegistrar = (server: McpServer, ctx: McpToolContext) => void;

package/dist/lib/mcp/types.js

@@ -0,0 +1,4 @@
+/**
+ * MCP Types and Interfaces
+ */
+export {};

package/dist/lib/multiline-input.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Multi-line text input utility for CLI.
+ *
+ * Provides inline TTY text input without opening external editors.
+ * Handles paste safely, supports cursor navigation, and provides
+ * clear visual feedback.
+ *
+ * Usage:
+ * ```typescript
+ * const text = await multiLineInput({
+ *   message: 'Enter description:',
+ *   default: 'Existing content...',
+ * });
+ * ```
+ */
+/**
+ * Options for multiLineInput
+ */
+export interface MultiLineInputOptions {
+    /** Prompt message displayed above the input area */
+    message: string;
+    /** Default/initial content to populate the input with */
+    default?: string;
+    /** Hint text shown below the input area (e.g., key bindings) */
+    hint?: string;
+    /** Whether input is required (empty not allowed) */
+    required?: boolean;
+    /** Validation function - returns true if valid, or error message */
+    validate?: (value: string) => boolean | string;
+}
+/**
+ * Result of multiLineInput
+ */
+export interface MultiLineInputResult {
+    /** The entered text */
+    value: string;
+    /** Whether input was cancelled (Ctrl+C) */
+    cancelled: boolean;
+}
+/**
+ * Collect multi-line input from the user with an inline TTY editor.
+ *
+ * Features:
+ * - Arrow key navigation
+ * - Backspace/delete
+ * - Copy-paste handling (escapes special characters)
+ * - Ctrl+D to finish, Ctrl+C to cancel
+ * - Pre-populated content support
+ * - Real-time visual feedback
+ *
+ * @param options Input options
+ * @returns The entered text and cancellation status
+ */
+export declare function multiLineInput(options: MultiLineInputOptions): Promise<MultiLineInputResult>;
+/**
+ * Convenience wrapper that returns just the value string.
+ * Throws if cancelled.
+ */
+export declare function promptMultiLine(options: MultiLineInputOptions): Promise<string>;
+/**
+ * Integration with FlagResolver - creates a prompt-compatible function
+ */
+export declare function createMultiLinePrompt(message: string, defaultValue?: string, hint?: string): () => Promise<string>;