@proletariat/cli 0.3.24 → 0.3.26

package/dist/commands/work/spawn.js

@@ -1,12 +1,11 @@
 import { Flags } from '@oclif/core';
 import * as path from 'node:path';
-import inquirer from 'inquirer';
 import Database from 'better-sqlite3';
 import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { getWorkspaceInfo, getTicketTmuxSession, killTmuxSession } from '../../lib/agents/commands.js';
 import { isDockerRunning, isGitHubTokenAvailable, isDevcontainerCliInstalled } from '../../lib/execution/runners.js';
-import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, outputConfirmationNeededAsJson, outputExecutionResultAsJson, } from '../../lib/prompt-json.js';
 import { FlagResolver } from '../../lib/flags/index.js';
 export default class WorkSpawn extends PMOCommand {
     static description = 'Spawn work for multiple tickets by column (batch mode)';
@@ -19,6 +18,7 @@ export default class WorkSpawn extends PMOCommand {
         '<%= config.bin %> <%= command.id %> TKT-001 TKT-002    # Spawn specific tickets by ID',
         '<%= config.bin %> <%= command.id %> --dry-run          # Preview without executing',
         '<%= config.bin %> <%= command.id %> --many --json      # Output ticket choices as JSON (for agents)',
+        '<%= config.bin %> <%= command.id %> TKT-001 --action custom --message "Add unit tests"  # Custom prompt',
     ];
     static flags = {
         ...pmoBaseFlags,
@@ -101,7 +101,10 @@ export default class WorkSpawn extends PMOCommand {
             default: false,
         }),
         action: Flags.string({
-            description: 'Action to perform (e.g., groom, implement, review). Prompts if not provided.',
+            description: 'Action to perform (e.g., groom, implement, review, custom). Prompts if not provided.',
+        }),
+        message: Flags.string({
+            description: 'Custom prompt/message for the agent (use with --action custom)',
         }),
         session: Flags.string({
             description: 'Session manager inside container (tmux runs agent in tmux inside container)',
@@ -251,18 +254,78 @@ export default class WorkSpawn extends PMOCommand {
                     db.close();
                     return handleError('NO_VALID_TICKETS', 'No valid tickets found from provided IDs.');
                 }
-                // In JSON mode with explicit tickets, output success
+                // In JSON mode with explicit tickets, check if we should execute or return confirmation
                 if (jsonMode) {
-                    outputSuccessAsJson({
-                        ticketsSelected: ticketsToSpawn.map(t => ({
-                            id: t.id,
-                            title: t.title,
-                            status: t.statusName,
-                        })),
-                        count: ticketsToSpawn.length,
-                    }, createMetadata('work spawn', flags));
-                    db.close();
-                    return;
+                    // Check if all required flags for non-interactive execution are provided
+                    const hasAction = !!flags.action;
+                    const hasDisplay = !!flags.display || flags['run-on-host'];
+                    const hasPermissions = flags['skip-permissions'] || flags['per-ticket']; // per-ticket mode prompts individually
+                    const allFlagsProvided = hasAction && hasDisplay && hasPermissions;
+                    if (allFlagsProvided && flags.yes) {
+                        // All flags provided and --yes is set: fall through to execution loop
+                        // Don't return here - continue to execution
+                    }
+                    else if (allFlagsProvided && !flags.yes) {
+                        // All flags provided but no --yes: return confirmation_needed with plan
+                        const metadata = createMetadata('work spawn', flags);
+                        // Build the confirm command with --yes
+                        const ticketIds = ticketsToSpawn.map(t => t.id).join(' ');
+                        let confirmCmd = `prlt work spawn ${ticketIds}`;
+                        if (flags.action)
+                            confirmCmd += ` --action ${flags.action}`;
+                        if (flags.display)
+                            confirmCmd += ` --display ${flags.display}`;
+                        if (flags['run-on-host'])
+                            confirmCmd += ' --run-on-host';
+                        if (flags['skip-permissions'])
+                            confirmCmd += ' --skip-permissions';
+                        if (flags.executor)
+                            confirmCmd += ` --executor ${flags.executor}`;
+                        if (flags.session)
+                            confirmCmd += ` --session ${flags.session}`;
+                        if (flags['create-pr'])
+                            confirmCmd += ' --create-pr';
+                        if (flags['no-pr'])
+                            confirmCmd += ' --no-pr';
+                        if (flags.clone)
+                            confirmCmd += ' --clone';
+                        if (flags.focus)
+                            confirmCmd += ' --focus';
+                        confirmCmd += ' --yes';
+                        const plan = {
+                            tickets: ticketsToSpawn.map(t => ({
+                                id: t.id,
+                                title: t.title,
+                                status: t.statusName,
+                            })),
+                            action: flags.action,
+                            display: flags.display || (flags['run-on-host'] ? 'host' : 'devcontainer'),
+                            permissions: flags['skip-permissions'] ? 'danger' : 'safe',
+                            count: ticketsToSpawn.length,
+                        };
+                        db.close();
+                        outputConfirmationNeededAsJson(plan, confirmCmd, `Ready to spawn ${ticketsToSpawn.length} agent(s). Run with --yes to execute.`, metadata);
+                        return;
+                    }
+                    else {
+                        // Missing required flags: return success with tickets selected (legacy behavior)
+                        // This allows the calling agent to see what tickets are available
+                        outputSuccessAsJson({
+                            ticketsSelected: ticketsToSpawn.map(t => ({
+                                id: t.id,
+                                title: t.title,
+                                status: t.statusName,
+                            })),
+                            count: ticketsToSpawn.length,
+                            missingFlags: {
+                                action: !hasAction,
+                                display: !hasDisplay,
+                                permissions: !hasPermissions,
+                            },
+                        }, createMetadata('work spawn', flags));
+                        db.close();
+                        return;
+                    }
                 }
                 this.log('');
                 this.log(styles.header(`🚀 Spawn: ${ticketsToSpawn.length} ticket(s)`));
@@ -392,23 +455,18 @@ export default class WorkSpawn extends PMOCommand {
                     }
                     ticketsByPriority.get(priority).push(ticket);
                 }
-                // Build choices with priority separators
-                const choices = [];
-                // Also build flat choices for JSON mode (without separators)
+                // Build flat choices for ticket selection
                 const flatChoices = [];
                 for (const priority of PRIORITY_ORDER) {
                     const tickets = ticketsByPriority.get(priority) || [];
                     if (tickets.length === 0)
                         continue;
-                    choices.push(new inquirer.Separator(`── ${priority} (${tickets.length}) ──`));
                     for (const ticket of tickets) {
                         const statusBadge = ticket.statusName ? ` [${ticket.statusName}]` : '';
-                        const ticketChoice = {
+                        flatChoices.push({
                             name: `[${priority}] ${ticket.id} - ${ticket.title}${statusBadge}`,
                             value: ticket.id,
-                        };
-                        choices.push(ticketChoice);
-                        flatChoices.push(ticketChoice);
+                        });
                     }
                 }
                 // Use FlagResolver for ticket selection (checkbox)
@@ -460,24 +518,25 @@ export default class WorkSpawn extends PMOCommand {
                 }
             }
             // Handle tickets with active sessions
+            const spawnJsonModeConfig = jsonMode ? { flags: flags, commandName: 'work spawn' } : null;
             if (ticketsWithActiveSessions.length > 0 && !jsonMode) {
                 this.log(styles.warning(`Found ${ticketsWithActiveSessions.length} ticket(s) with active tmux sessions:`));
                 for (const { ticketId, agent } of ticketsWithActiveSessions) {
                     this.log(styles.muted(`  ${ticketId} → ${agent}`));
                 }
                 this.log('');
-                const { sessionAction } = await inquirer.prompt([
+                const { sessionAction } = await this.prompt([
                     {
                         type: 'list',
                         name: 'sessionAction',
                         message: 'What would you like to do with these tickets?',
                         choices: [
-                            { name: 'Skip them (only spawn tickets without active sessions)', value: 'skip' },
-                            { name: 'Kill sessions and respawn with new agents', value: 'kill' },
-                            { name: 'Cancel', value: 'cancel' },
+                            { name: 'Skip them (only spawn tickets without active sessions)', value: 'skip', command: 'prlt work spawn --json' },
+                            { name: 'Kill sessions and respawn with new agents', value: 'kill', command: 'prlt work spawn --json' },
+                            { name: 'Cancel', value: 'cancel', command: '' },
                         ],
                     },
-                ]);
+                ], spawnJsonModeConfig);
                 if (sessionAction === 'cancel') {
                     db.close();
                     this.log(styles.muted('Cancelled.'));
@@ -522,6 +581,8 @@ export default class WorkSpawn extends PMOCommand {
             let batchNoPr = flags['no-pr'];
             let batchRunOnHost = flags['run-on-host'];
             let batchAction = flags.action;
+            // Track custom message for custom action (needs to be outside the if block)
+            let batchCustomMessage = flags.message;
             // Track display mode separately for devcontainer (needs to be outside the if block)
             let batchDisplayMode;
             // For ephemeral agents, we'll create devcontainers on-demand
@@ -542,12 +603,16 @@ export default class WorkSpawn extends PMOCommand {
                         name: `${a.id.padEnd(12)} - ${a.description || a.name}`,
                         value: a.id,
                     }));
-                    // Add adhoc option at the end
+                    // Add custom and adhoc options at the end
+                    actionChoices.push({
+                        name: 'custom       - Enter a custom prompt/instruction',
+                        value: '__custom__',
+                    });
                     actionChoices.push({
                         name: 'adhoc        - Unstructured exploration/debugging',
                         value: '__adhoc__',
                     });
-                    // Use FlagResolver for action selection
+                    // Use FlagResolver for action selection with optional custom input
                     const actionResolver = new FlagResolver({
                         commandName: 'work spawn',
                         baseCommand: 'prlt work spawn',
@@ -561,12 +626,54 @@ export default class WorkSpawn extends PMOCommand {
                         default: 'implement',
                         choices: () => actionChoices,
                     });
+                    actionResolver.addPrompt({
+                        flagName: 'customInput',
+                        type: 'input',
+                        message: 'Enter custom prompt for the agent:',
+                        when: (ctx) => ctx.flags.selectedAction === '__custom__',
+                        validate: (value) => value.trim() ? true : 'Prompt cannot be empty',
+                    });
                     const actionResult = await actionResolver.resolve();
                     const selectedAction = actionResult.selectedAction;
-                    batchAction = selectedAction === '__adhoc__' ? 'adhoc' : selectedAction;
+                    if (selectedAction === '__custom__') {
+                        batchAction = 'custom';
+                        batchCustomMessage = actionResult.customInput.trim();
+                    }
+                    else if (selectedAction === '__adhoc__') {
+                        batchAction = 'adhoc';
+                    }
+                    else {
+                        batchAction = selectedAction;
+                    }
+                }
+                else if (flags.action === 'custom') {
+                    // Custom action specified via flag - require --message
+                    if (!flags.message) {
+                        db.close();
+                        return handleError('MISSING_MESSAGE', '--action custom requires --message flag with the custom prompt');
+                    }
+                    batchAction = 'custom';
+                    batchCustomMessage = flags.message;
+                }
+                else if (flags.message && flags.action !== 'custom') {
+                    // --message provided without --action custom - warn user
+                    this.warn('--message flag is only used with --action custom, ignoring');
                 }
                 // Now fetch action details after selection is made
-                if (batchAction === 'adhoc') {
+                if (batchAction === 'custom') {
+                    // Custom action - user provides their own prompt
+                    selectedActionDetails = {
+                        id: 'custom',
+                        name: 'Custom',
+                        description: 'Custom prompt/instruction',
+                        prompt: batchCustomMessage || '',
+                        modifiesCode: true, // Assume custom prompts may modify code
+                        defaultMoveToCategory: 'started',
+                        isBuiltin: false,
+                        createdAt: new Date(),
+                    };
+                }
+                else if (batchAction === 'adhoc') {
                     // Adhoc is a synthetic action, not stored in database
                     selectedActionDetails = {
                         id: 'adhoc',
@@ -678,7 +785,7 @@ export default class WorkSpawn extends PMOCommand {
                     let environmentSelected = false;
                     while (!environmentSelected) {
                         // eslint-disable-next-line no-await-in-loop -- Interactive loop with retry on Docker check
-                        const { selectedEnvironment } = await inquirer.prompt([
+                        const { selectedEnvironment } = await this.prompt([
                             {
                                 type: 'list',
                                 name: 'selectedEnvironment',
@@ -686,7 +793,7 @@ export default class WorkSpawn extends PMOCommand {
                                 choices: envChoices,
                                 default: devcontainerReady ? 'devcontainer' : 'host',
                             },
-                        ]);
+                        ], spawnJsonModeConfig);
                         if (selectedEnvironment === 'cancel') {
                             db.close();
                             this.log(styles.muted('Cancelled.'));
@@ -760,18 +867,18 @@ export default class WorkSpawn extends PMOCommand {
                             // For devcontainer, prompt for display mode
                             // Simplified: tmux is always used inside container for session persistence
                             // eslint-disable-next-line no-await-in-loop -- Follow-up prompt after selection
-                            const { selectedDisplay } = await inquirer.prompt([
+                            const { selectedDisplay } = await this.prompt([
                                 {
                                     type: 'list',
                                     name: 'selectedDisplay',
                                     message: 'How should agent output be displayed?',
                                     choices: [
-                                        { name: '🖥️  New tab      - Opens in new terminal tab (recommended)', value: 'terminal' },
-                                        { name: '📦 Background  - Runs detached, reattach with: prlt session attach', value: 'background' },
+                                        { name: '🖥️  New tab      - Opens in new terminal tab (recommended)', value: 'terminal', command: 'prlt work spawn --display terminal --json' },
+                                        { name: '📦 Background  - Runs detached, reattach with: prlt session attach', value: 'background', command: 'prlt work spawn --display background --json' },
                                     ],
                                     default: 'terminal',
                                 },
-                            ]);
+                            ], spawnJsonModeConfig);
                             batchDisplayMode = selectedDisplay;
                             // Always use tmux inside container for session persistence
                             flags.session = 'tmux';
@@ -836,26 +943,33 @@ export default class WorkSpawn extends PMOCommand {
                 const actionModifiesCode = selectedActionDetails?.modifiesCode ?? true;
                 if (!batchCreatePr && !batchNoPr) {
                     if (actionModifiesCode) {
-                        // Use FlagResolver for PR choice
-                        const prResolver = new FlagResolver({
-                            commandName: 'work spawn',
-                            baseCommand: 'prlt work spawn',
-                            jsonMode,
-                            flags: {},
-                        });
-                        prResolver.addPrompt({
-                            flagName: 'prChoice',
-                            type: 'list',
-                            message: 'Create pull requests when work is ready?',
-                            default: 'yes',
-                            choices: () => [
-                                { name: '✓ Yes - Create PR for each ticket', value: 'yes' },
-                                { name: '✗ No  - Just move tickets to review', value: 'no' },
-                            ],
-                        });
-                        const prResult = await prResolver.resolve();
-                        batchCreatePr = prResult.prChoice === 'yes';
-                        batchNoPr = prResult.prChoice === 'no';
+                        // In JSON mode with --yes, default to creating PRs for code-modifying actions
+                        if (jsonMode && flags.yes) {
+                            batchCreatePr = true;
+                            batchNoPr = false;
+                        }
+                        else {
+                            // Use FlagResolver for PR choice
+                            const prResolver = new FlagResolver({
+                                commandName: 'work spawn',
+                                baseCommand: 'prlt work spawn',
+                                jsonMode,
+                                flags: {},
+                            });
+                            prResolver.addPrompt({
+                                flagName: 'prChoice',
+                                type: 'list',
+                                message: 'Create pull requests when work is ready?',
+                                default: 'yes',
+                                choices: () => [
+                                    { name: '✓ Yes - Create PR for each ticket', value: 'yes' },
+                                    { name: '✗ No  - Just move tickets to review', value: 'no' },
+                                ],
+                            });
+                            const prResult = await prResolver.resolve();
+                            batchCreatePr = prResult.prChoice === 'yes';
+                            batchNoPr = prResult.prChoice === 'no';
+                        }
                     }
                     else {
                         // Non-code-modifying action - no PR needed
@@ -874,10 +988,14 @@ export default class WorkSpawn extends PMOCommand {
             // Spawn each ticket - work:start will create ephemeral agents on-demand
             let successCount = 0;
             let failCount = 0;
+            // Track execution results for JSON output
+            const executionResults = [];
             // Process sequentially for clear logging and resource management
             for (const ticket of ticketsToSpawn) {
                 try {
-                    this.log(styles.muted(`Starting ${ticket.id} with ephemeral agent...`));
+                    if (!jsonMode) {
+                        this.log(styles.muted(`Starting ${ticket.id} with ephemeral agent...`));
+                    }
                     // Build args for work:start
                     // IMPORTANT: Pass --project to avoid re-prompting for project selection
                     // Pass --ephemeral to signal work:start should create an ephemeral agent
@@ -885,6 +1003,10 @@ export default class WorkSpawn extends PMOCommand {
                     // Pass clone flag if specified
                     if (flags.clone)
                         startArgs.push('--clone');
+                    // In JSON mode with --yes, pass --yes to work:start to skip prompts there too
+                    if (jsonMode && flags.yes) {
+                        startArgs.push('--yes');
+                    }
                     if (flags['per-ticket']) {
                         // Per-ticket mode: only pass display flag, let start prompt for the rest
                         // batchDisplayMode is for devcontainer, batchDisplay is for host
@@ -899,6 +1021,13 @@ export default class WorkSpawn extends PMOCommand {
                             startArgs.push('--force');
                         if (flags.focus)
                             startArgs.push('--focus');
+                        // Pass action/prompt - custom action uses --prompt, others use --action
+                        if (batchAction === 'custom' && batchCustomMessage) {
+                            startArgs.push('--prompt', batchCustomMessage);
+                        }
+                        else if (batchAction) {
+                            startArgs.push('--action', batchAction);
+                        }
                     }
                     else {
                         // Batch mode: pass all settings to skip prompts
@@ -920,8 +1049,13 @@ export default class WorkSpawn extends PMOCommand {
                             startArgs.push('--create-pr');
                         if (batchNoPr)
                             startArgs.push('--no-pr');
-                        // Pass action flag (from prompt or flag)
-                        startArgs.push('--action', batchAction || 'implement');
+                        // Pass action/prompt - custom action uses --prompt, others use --action
+                        if (batchAction === 'custom' && batchCustomMessage) {
+                            startArgs.push('--prompt', batchCustomMessage);
+                        }
+                        else {
+                            startArgs.push('--action', batchAction || 'implement');
+                        }
                         // Pass session manager (tmux inside container by default)
                         if (flags.session)
                             startArgs.push('--session', flags.session);
@@ -932,16 +1066,43 @@ export default class WorkSpawn extends PMOCommand {
                     // eslint-disable-next-line no-await-in-loop
                     await this.config.runCommand('work:start', startArgs);
                     successCount++;
+                    // Track for JSON output
+                    executionResults.push({
+                        workId: `WORK-${ticket.id}`, // Placeholder - actual work ID comes from work:start
+                        ticketId: ticket.id,
+                        agent: 'ephemeral', // Ephemeral agent name determined by work:start
+                        status: 'running',
+                    });
                 }
                 catch (error) {
                     failCount++;
-                    this.log(styles.error(`Failed to start ${ticket.id}: ${error instanceof Error ? error.message : error}`));
+                    if (!jsonMode) {
+                        this.log(styles.error(`Failed to start ${ticket.id}: ${error instanceof Error ? error.message : error}`));
+                    }
+                    // Track failed executions for JSON output
+                    executionResults.push({
+                        workId: '',
+                        ticketId: ticket.id,
+                        agent: '',
+                        status: 'failed',
+                    });
                 }
             }
-            await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+            await autoExportToBoard(this.pmoPath, this.storage, (msg) => {
+                if (!jsonMode) {
+                    this.log(styles.muted(msg));
+                }
+            });
             db.close();
-            this.log('');
-            this.log(styles.success(`✓ Spawn results: ${successCount} started, ${failCount} failed`));
+            // Output results
+            if (jsonMode) {
+                // Output JSON execution results
+                outputExecutionResultAsJson(executionResults, successCount, failCount, createMetadata('work spawn', flags));
+            }
+            else {
+                this.log('');
+                this.log(styles.success(`✓ Spawn results: ${successCount} started, ${failCount} failed`));
+            }
         }
         catch (error) {
             db.close();

package/dist/commands/work/start.d.ts

@@ -27,6 +27,7 @@ export default class WorkStart extends PMOCommand {
         ephemeral: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         focus: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         clone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     execute(): Promise<void>;