@proletariat/cli 0.3.23 → 0.3.24

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/prompt-json.d.ts

@@ -91,6 +91,8 @@ export interface OutputMetadata {
  * JSON output when a prompt would be shown
  */
 export interface PromptJsonOutput {
+    /** Output type discriminator */
+    type: 'prompt';
     /** Prompt configuration, or null if no prompt needed */
     prompt: PromptConfig | null;
     /** Command metadata */
@@ -100,6 +102,8 @@ export interface PromptJsonOutput {
  * JSON output for successful command execution (no prompt needed)
  */
 export interface SuccessJsonOutput {
+    /** Output type discriminator */
+    type: 'success';
     /** Always null when success output */
     prompt: null;
     /** Indicates successful execution */
@@ -113,6 +117,8 @@ export interface SuccessJsonOutput {
  * JSON output for error conditions
  */
 export interface ErrorJsonOutput {
+    /** Output type discriminator */
+    type: 'error';
     /** Error details */
     error: {
         /** Machine-readable error code (e.g., "NO_TICKETS_AVAILABLE") */
@@ -123,10 +129,31 @@ export interface ErrorJsonOutput {
     /** Command metadata */
     metadata: OutputMetadata;
 }
+/**
+ * JSON output for dry-run validation (what would happen)
+ */
+export interface DryRunJsonOutput {
+    /** Indicates this is a dry-run result */
+    type: 'dry-run';
+    /** Whether the inputs are valid */
+    valid: boolean;
+    /** What would be created if valid */
+    wouldCreate?: {
+        type: string;
+        [key: string]: unknown;
+    };
+    /** Validation errors if invalid */
+    errors?: Array<{
+        field: string;
+        error: string;
+    }>;
+    /** Command metadata */
+    metadata: OutputMetadata;
+}
 /**
  * Union type for all JSON output types
  */
-export type JsonOutput = PromptJsonOutput | SuccessJsonOutput | ErrorJsonOutput;
+export type JsonOutput = PromptJsonOutput | SuccessJsonOutput | ErrorJsonOutput | DryRunJsonOutput;
 /**
  * Flags interface for JSON mode detection
  */
@@ -253,3 +280,27 @@ export declare function buildPromptConfig(type: 'list' | 'checkbox' | 'confirm'
  * @returns PromptConfig object with type 'form'
  */
 export declare function buildFormPromptConfig(fields: FormField[]): PromptConfig;
+/**
+ * Output a successful dry-run result as JSON and exit
+ *
+ * Use this when --dry-run is set and all validation passes.
+ * Shows what would be created without actually creating it.
+ *
+ * @param entityType - Type of entity that would be created (e.g., "ticket", "project")
+ * @param wouldCreate - Data about what would be created
+ * @param metadata - Command metadata
+ */
+export declare function outputDryRunSuccessAsJson(entityType: string, wouldCreate: Record<string, unknown>, metadata: OutputMetadata): never;
+/**
+ * Output a dry-run validation failure as JSON and exit
+ *
+ * Use this when --dry-run is set and validation fails.
+ * Shows the validation errors without attempting to create.
+ *
+ * @param errors - Array of validation errors
+ * @param metadata - Command metadata
+ */
+export declare function outputDryRunErrorsAsJson(errors: Array<{
+    field: string;
+    error: string;
+}>, metadata: OutputMetadata): never;

package/dist/lib/prompt-json.js

@@ -111,6 +111,7 @@ export function createMetadata(command, flags) {
  */
 export function outputPromptAsJson(config, metadata) {
     const output = {
+        type: 'prompt',
         prompt: config,
         metadata,
     };
@@ -129,6 +130,7 @@ export function outputPromptAsJson(config, metadata) {
  */
 export function outputSuccessAsJson(result, metadata) {
     const output = {
+        type: 'success',
         prompt: null,
         success: true,
         result,
@@ -150,6 +152,7 @@ export function outputSuccessAsJson(result, metadata) {
  */
 export function outputErrorAsJson(code, message, metadata) {
     const output = {
+        type: 'error',
         error: {
             code,
             message,
@@ -235,3 +238,45 @@ export function buildFormPromptConfig(fields) {
         fields,
     };
 }
+/**
+ * Output a successful dry-run result as JSON and exit
+ *
+ * Use this when --dry-run is set and all validation passes.
+ * Shows what would be created without actually creating it.
+ *
+ * @param entityType - Type of entity that would be created (e.g., "ticket", "project")
+ * @param wouldCreate - Data about what would be created
+ * @param metadata - Command metadata
+ */
+export function outputDryRunSuccessAsJson(entityType, wouldCreate, metadata) {
+    const output = {
+        type: 'dry-run',
+        valid: true,
+        wouldCreate: {
+            type: entityType,
+            ...wouldCreate,
+        },
+        metadata,
+    };
+    console.log(JSON.stringify(output, null, 2));
+    process.exit(EXIT_SUCCESS);
+}
+/**
+ * Output a dry-run validation failure as JSON and exit
+ *
+ * Use this when --dry-run is set and validation fails.
+ * Shows the validation errors without attempting to create.
+ *
+ * @param errors - Array of validation errors
+ * @param metadata - Command metadata
+ */
+export function outputDryRunErrorsAsJson(errors, metadata) {
+    const output = {
+        type: 'dry-run',
+        valid: false,
+        errors,
+        metadata,
+    };
+    console.log(JSON.stringify(output, null, 2));
+    process.exit(EXIT_ERROR);
+}