@proletariat/cli 0.3.34 → 0.3.36

package/dist/lib/execution/storage.d.ts

@@ -71,6 +71,11 @@ export declare class ExecutionStorage {
      * Returns the number of stale executions cleaned up.
      */
     cleanupStaleExecutions(): number;
+    /**
+     * Find container sessions using prefix matching.
+     * Handles cases where the stored containerId format differs from docker ps output.
+     */
+    private findContainerSessionsByPrefix;
     /**
      * Get list of host tmux session names
      */

package/dist/lib/execution/storage.js

@@ -215,9 +215,9 @@ export class ExecutionStorage {
             }
             let sessionExists = false;
             if (exec.environment === 'devcontainer' && exec.containerId) {
-                // Check if session exists in container
-                const containerSessions = containerTmuxSessions.get(exec.containerId);
-                sessionExists = containerSessions?.includes(exec.sessionId) ?? false;
+                // Check if session exists in container (use prefix matching for ID format differences)
+                const containerSessions = this.findContainerSessionsByPrefix(containerTmuxSessions, exec.containerId);
+                sessionExists = containerSessions.includes(exec.sessionId);
             }
             else {
                 // Check if session exists on host
@@ -231,6 +231,21 @@ export class ExecutionStorage {
         }
         return cleanedCount;
     }
+    /**
+     * Find container sessions using prefix matching.
+     * Handles cases where the stored containerId format differs from docker ps output.
+     */
+    findContainerSessionsByPrefix(containerTmuxSessions, containerId) {
+        const exact = containerTmuxSessions.get(containerId);
+        if (exact)
+            return exact;
+        for (const [key, sessions] of containerTmuxSessions) {
+            if (key.startsWith(containerId) || containerId.startsWith(key)) {
+                return sessions;
+            }
+        }
+        return [];
+    }
     /**
      * Get list of host tmux session names
      */

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

@@ -87,6 +87,7 @@ export interface ExecutionContext {
     actionEndPrompt?: string;
     modifiesCode?: boolean;
     customMessage?: string;
+    useApiKey?: boolean;
     prFeedback?: string;
     isRevision?: boolean;
 }
@@ -111,6 +112,7 @@ export declare function getBranchType(category?: string): string;
  * - agent: the AI agent doing the work
  */
 export declare function generateBranchName(ticketId: string, ticketTitle: string, ownerName: string, agentName: string, category?: string): string;
+export type AuthMethod = 'oauth' | 'apikey';
 export interface ExecutionConfig {
     defaultEnvironment: ExecutionEnvironment;
     defaultExecutor: ExecutorType;
@@ -118,6 +120,7 @@ export interface ExecutionConfig {
     shell: Shell;
     outputMode: OutputMode;
     sandboxed: boolean;
+    authMethod?: AuthMethod;
     tmux: {
         session: string;
         layout: 'split' | 'window';

package/dist/lib/flags/resolver.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
 /**
  * FlagResolver - Unified flag resolution for human and machine interactive modes
  *

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

@@ -3,9 +3,8 @@
  */
 import { z } from 'zod';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult, ServerRequest, ServerNotification } from '@modelcontextprotocol/sdk/types.js';
 import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import type { ServerRequest, ServerNotification } from '@modelcontextprotocol/sdk/types.js';
 import type { Ticket } from '../pmo/types.js';
 import type { McpToolResult } from './types.js';
 /**

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

@@ -2,9 +2,9 @@
  * MCP Board Tools
  */
 import { z } from 'zod';
-import { errorResponse, strictTool } from '../helpers.js';
+import { formatTicket, errorResponse, strictTool } from '../helpers.js';
 export function registerBoardTools(server, ctx) {
-    strictTool(server, 'board_show', 'Show the kanban board', { project: z.string().optional().describe('Project ID') }, async (params) => {
+    strictTool(server, 'board_view', 'Show the kanban board', { project: z.string().optional().describe('Project ID') }, async (params) => {
         try {
             let projectId = params.project;
             if (!projectId) {
@@ -27,10 +27,8 @@ export function registerBoardTools(server, ctx) {
                                     position: col.position,
                                     ticketCount: col.tickets.length,
                                     tickets: col.tickets.map((t) => ({
-                                        id: t.id,
-                                        title: t.title,
-                                        priority: t.priority,
-                                        assignee: t.assignee,
+                                        ...formatTicket(t),
+                                        labels: t.labels,
                                     })),
                                 })),
                                 updatedAt: board.updatedAt.toISOString(),

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

@@ -17,9 +17,26 @@ export function registerAgentTools(server, ctx) {
             return errorResponse(error);
         }
     });
-    strictTool(server, 'agent_status', 'Check agent status', {}, async () => {
+    strictTool(server, 'agent_status', 'Check agent status. With agent param, returns that agent\'s status. Without, auto-detects current agent or returns all agent statuses.', { agent: z.string().optional().describe('Agent name. If omitted, auto-detects current agent or returns all.') }, async (params) => {
         try {
-            const output = ctx.runCommand('prlt agent status --json 2>/dev/null || prlt agent status');
+            if (params.agent) {
+                const output = ctx.runCommand(`prlt agent status ${params.agent} --json`);
+                return textResponse(output);
+            }
+            // Try auto-detecting current agent via whoami
+            try {
+                const whoamiOutput = ctx.runCommand('prlt whoami --json');
+                const whoami = JSON.parse(whoamiOutput);
+                if (whoami.agent) {
+                    const output = ctx.runCommand(`prlt agent status ${whoami.agent} --json`);
+                    return textResponse(output);
+                }
+            }
+            catch {
+                // whoami failed or no agent detected, fall through
+            }
+            // No agent detected - return all agent statuses
+            const output = ctx.runCommand('prlt agent status --json');
             return textResponse(output);
         }
         catch (error) {
@@ -139,7 +156,7 @@ export function registerRepoTools(server, ctx) {
     });
 }
 export function registerBranchTools(server, ctx) {
-    strictTool(server, 'branch_list', 'List branches', {}, async () => {
+    strictTool(server, 'branch_list', 'List branches (across all HQ repos if not in a git repo)', {}, async () => {
         try {
             const output = ctx.runCommand('prlt branch list');
             return textResponse(output);
@@ -161,9 +178,11 @@ export function registerBranchTools(server, ctx) {
             return errorResponse(error);
         }
     });
-    strictTool(server, 'branch_where', 'Show which ticket/branch you are on', {}, async () => {
+    strictTool(server, 'branch_where', 'Find which directory a branch is checked out in', {
+        search: z.string().describe('Branch name or ticket ID to search for'),
+    }, async (params) => {
         try {
-            const output = ctx.runCommand('prlt branch where');
+            const output = ctx.runCommand(`prlt branch where ${params.search}`);
             return textResponse(output);
         }
         catch (error) {
@@ -314,7 +333,7 @@ export function registerUtilityTools(server, ctx) {
     });
     strictTool(server, 'session_list', 'List tmux sessions', {}, async () => {
         try {
-            const output = ctx.runCommand('prlt session list');
+            const output = ctx.runCommand('prlt session list --json');
             return textResponse(output);
         }
         catch (error) {

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

@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
 /**
  * MCP Diet & Pull Tools
  */

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

@@ -71,7 +71,7 @@ export function registerEpicTools(server, ctx) {
             return errorResponse(error);
         }
     });
-    strictTool(server, 'epic_show', 'Get epic details with tickets', { id: z.string().describe('Epic ID') }, async (params) => {
+    strictTool(server, 'epic_view', 'Get epic details with tickets', { id: z.string().describe('Epic ID') }, async (params) => {
         try {
             const epic = await ctx.storage.getEpic(params.id);
             if (!epic)
@@ -83,9 +83,14 @@ export function registerEpicTools(server, ctx) {
                         text: JSON.stringify({
                             success: true,
                             epic: {
-                                ...epic,
+                                id: epic.id,
+                                projectId: epic.projectId,
+                                title: epic.title,
+                                status: epic.status,
+                                position: epic.position,
+                                specId: epic.specId,
                                 ticketCount: tickets.length,
-                                tickets: tickets.map((t) => ({ id: t.id, title: t.title, statusName: t.statusName, priority: t.priority })),
+                                tickets: tickets.map((t) => ({ id: t.id, title: t.title, statusName: t.statusName, priority: t.priority, category: t.category })),
                                 createdAt: epic.createdAt.toISOString(),
                                 updatedAt: epic.updatedAt.toISOString(),
                             },

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

@@ -16,4 +16,5 @@ export { registerCategoryTools } from './category.js';
 export { registerTemplateTools } from './template.js';
 export { registerViewTools } from './view.js';
 export { registerDietTools } from './diet.js';
+export { registerLabelTools } from './label.js';
 export { registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from './cli-passthrough.js';

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

@@ -16,5 +16,6 @@ export { registerCategoryTools } from './category.js';
 export { registerTemplateTools } from './template.js';
 export { registerViewTools } from './view.js';
 export { registerDietTools } from './diet.js';
+export { registerLabelTools } from './label.js';
 // CLI passthrough tools
 export { registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from './cli-passthrough.js';

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

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

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

@@ -0,0 +1,338 @@
+/**
+ * MCP Label Tools
+ */
+import { z } from 'zod';
+import { errorResponse, strictTool } from '../helpers.js';
+export function registerLabelTools(server, ctx) {
+    // ===========================================================================
+    // Label Group Tools
+    // ===========================================================================
+    strictTool(server, 'label_group_list', 'List all label groups', {
+        search: z.string().optional().describe('Search in name/description'),
+    }, async (params) => {
+        try {
+            const groups = await ctx.storage.listLabelGroups({
+                search: params.search,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count: groups.length,
+                            groups: groups.map(g => ({
+                                id: g.id,
+                                name: g.name,
+                                description: g.description,
+                                isExclusive: g.isExclusive,
+                                isRequired: g.isRequired,
+                                position: g.position,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_group_create', 'Create a new label group', {
+        name: z.string().describe('Group name (must be unique)'),
+        description: z.string().optional().describe('Group description'),
+        is_exclusive: z.boolean().optional().describe('Only one label from this group per ticket (default: true)'),
+        is_required: z.boolean().optional().describe('Must have one label from this group (default: false)'),
+    }, async (params) => {
+        try {
+            const group = await ctx.storage.createLabelGroup({
+                name: params.name,
+                description: params.description,
+                isExclusive: params.is_exclusive,
+                isRequired: params.is_required,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            group: {
+                                id: group.id,
+                                name: group.name,
+                                description: group.description,
+                                isExclusive: group.isExclusive,
+                                isRequired: group.isRequired,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_group_update', 'Update a label group', {
+        id: z.string().describe('Group ID'),
+        name: z.string().optional().describe('New name'),
+        description: z.string().optional().describe('New description'),
+        is_exclusive: z.boolean().optional().describe('Only one label from this group per ticket'),
+        is_required: z.boolean().optional().describe('Must have one label from this group'),
+    }, async (params) => {
+        try {
+            const changes = {};
+            if (params.name !== undefined)
+                changes.name = params.name;
+            if (params.description !== undefined)
+                changes.description = params.description;
+            if (params.is_exclusive !== undefined)
+                changes.isExclusive = params.is_exclusive;
+            if (params.is_required !== undefined)
+                changes.isRequired = params.is_required;
+            const group = await ctx.storage.updateLabelGroup(params.id, changes);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            group: {
+                                id: group.id,
+                                name: group.name,
+                                description: group.description,
+                                isExclusive: group.isExclusive,
+                                isRequired: group.isRequired,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_group_delete', 'Delete a label group (labels in the group become ungrouped)', {
+        id: z.string().describe('Group ID'),
+    }, async (params) => {
+        try {
+            await ctx.storage.deleteLabelGroup(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: `Deleted label group ${params.id}` }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    // ===========================================================================
+    // Label Tools
+    // ===========================================================================
+    strictTool(server, 'label_list', 'List all labels, optionally filtered by group', {
+        group: z.string().optional().describe('Filter by group ID'),
+        search: z.string().optional().describe('Search in name/description'),
+    }, async (params) => {
+        try {
+            const labels = await ctx.storage.listLabels({
+                groupId: params.group,
+                search: params.search,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count: labels.length,
+                            labels: labels.map(l => ({
+                                id: l.id,
+                                name: l.name,
+                                color: l.color,
+                                description: l.description,
+                                groupId: l.groupId,
+                                groupName: l.groupName,
+                                isBuiltin: l.isBuiltin,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_create', 'Create a new label', {
+        name: z.string().describe('Label name'),
+        color: z.string().optional().describe('Label color (hex, e.g. #ff0000)'),
+        description: z.string().optional().describe('Label description'),
+        group_id: z.string().optional().describe('Label group ID to add this label to'),
+    }, async (params) => {
+        try {
+            const label = await ctx.storage.createLabel({
+                name: params.name,
+                color: params.color,
+                description: params.description,
+                groupId: params.group_id,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            label: {
+                                id: label.id,
+                                name: label.name,
+                                color: label.color,
+                                description: label.description,
+                                groupId: label.groupId,
+                                groupName: label.groupName,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_update', 'Update a label (rename, recolor, regroup)', {
+        id: z.string().describe('Label ID'),
+        name: z.string().optional().describe('New name'),
+        color: z.string().optional().describe('New color (hex)'),
+        description: z.string().optional().describe('New description'),
+        group_id: z.string().optional().describe('Move to different group'),
+    }, async (params) => {
+        try {
+            const changes = {};
+            if (params.name !== undefined)
+                changes.name = params.name;
+            if (params.color !== undefined)
+                changes.color = params.color;
+            if (params.description !== undefined)
+                changes.description = params.description;
+            if (params.group_id !== undefined)
+                changes.groupId = params.group_id;
+            const label = await ctx.storage.updateLabel(params.id, changes);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            label: {
+                                id: label.id,
+                                name: label.name,
+                                color: label.color,
+                                description: label.description,
+                                groupId: label.groupId,
+                                groupName: label.groupName,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'label_delete', 'Delete a label (removes from all tickets)', {
+        id: z.string().describe('Label ID'),
+    }, async (params) => {
+        try {
+            await ctx.storage.deleteLabel(params.id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: `Deleted label ${params.id}` }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    // ===========================================================================
+    // Ticket-Label Association Tools
+    // ===========================================================================
+    strictTool(server, 'ticket_add_label', 'Add a label to a ticket. For exclusive groups, replaces existing label from same group.', {
+        ticket_id: z.string().describe('Ticket ID'),
+        label: z.string().describe('Label ID or name (supports group:name format)'),
+    }, async (params) => {
+        try {
+            // Try by ID first, then by name
+            const labelById = await ctx.storage.getLabel(params.label);
+            if (labelById) {
+                await ctx.storage.addLabelToTicket(params.ticket_id, labelById.id);
+            }
+            else {
+                await ctx.storage.addLabelToTicketByName(params.ticket_id, params.label);
+            }
+            const labels = await ctx.storage.getLabelsForTicket(params.ticket_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Label added to ${params.ticket_id}`,
+                            labels: labels.map(l => ({
+                                id: l.id,
+                                name: l.name,
+                                groupName: l.groupName,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'ticket_remove_label', 'Remove a label from a ticket', {
+        ticket_id: z.string().describe('Ticket ID'),
+        label: z.string().describe('Label ID or name'),
+    }, async (params) => {
+        try {
+            const labelById = await ctx.storage.getLabel(params.label);
+            if (labelById) {
+                await ctx.storage.removeLabelFromTicket(params.ticket_id, labelById.id);
+            }
+            else {
+                await ctx.storage.removeLabelFromTicketByName(params.ticket_id, params.label);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Label removed from ${params.ticket_id}`,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+    strictTool(server, 'ticket_labels', 'List all labels on a ticket', {
+        ticket_id: z.string().describe('Ticket ID'),
+    }, async (params) => {
+        try {
+            const labels = await ctx.storage.getLabelsForTicket(params.ticket_id);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count: labels.length,
+                            labels: labels.map(l => ({
+                                id: l.id,
+                                name: l.name,
+                                color: l.color,
+                                groupId: l.groupId,
+                                groupName: l.groupName,
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    });
+}

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

@@ -67,7 +67,7 @@ export function registerSpecTools(server, ctx) {
             return errorResponse(error);
         }
     });
-    strictTool(server, 'spec_show', 'Get spec details', { id: z.string().describe('Spec ID') }, async (params) => {
+    strictTool(server, 'spec_view', 'Get spec details', { id: z.string().describe('Spec ID') }, async (params) => {
         try {
             const spec = await ctx.storage.getSpec(params.id);
             if (!spec)