@proletariat/cli 0.3.16 → 0.3.18

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

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

package/dist/commands/work/spawn.js

@@ -6,7 +6,8 @@ import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index
 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, outputPromptAsJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } 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)';
     static strict = false; // Allow multiple ticket ID args without defining them
@@ -116,10 +117,16 @@ export default class WorkSpawn extends PMOCommand {
     };
     async execute() {
         const { flags, argv } = await this.parse(WorkSpawn);
-        // This command requires project context
-        const projectId = await this.requireProject();
         // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
+        // This command requires project context (pass JSON mode config for AI agents)
+        const projectId = await this.requireProject({
+            jsonMode: {
+                flags,
+                commandName: 'work spawn',
+                baseCommand: 'prlt work spawn',
+            },
+        });
         // Helper to handle errors in JSON mode
         const handleError = (code, message) => {
             if (jsonMode) {
@@ -177,28 +184,27 @@ export default class WorkSpawn extends PMOCommand {
                 spawnMode = 'many';
             }
             else if (!flags.column) {
-                // In JSON mode without explicit flags, output the mode selection prompt
-                if (jsonMode) {
-                    outputPromptAsJson(buildPromptConfig('list', 'mode', 'How would you like to spawn work?', [
-                        { name: 'All - Spawn all tickets tickets in a column', value: 'all' },
-                        { name: 'Many - Select specific tickets to spawn', value: 'many' },
-                    ]), createMetadata('work spawn', flags));
-                    db.close();
-                    return;
-                }
-                // Interactive: ask user
-                const { mode } = await inquirer.prompt([
-                    {
-                        type: 'list',
-                        name: 'mode',
-                        message: 'How would you like to spawn work?',
-                        choices: [
-                            { name: '📦 All    - Spawn all tickets tickets in a column', value: 'all' },
-                            { name: '✅ Many   - Select specific tickets to spawn', value: 'many' },
-                        ],
-                    },
-                ]);
-                spawnMode = mode;
+                // Use FlagResolver for mode selection prompt
+                const modeResolver = new FlagResolver({
+                    commandName: 'work spawn',
+                    baseCommand: 'prlt work spawn',
+                    jsonMode,
+                    flags: {},
+                    context: { projectId },
+                });
+                modeResolver.addPrompt({
+                    flagName: 'mode',
+                    type: 'list',
+                    message: 'How would you like to spawn work?',
+                    choices: () => [
+                        { name: jsonMode ? 'All - Spawn all tickets in a column' : '📦 All    - Spawn all tickets tickets in a column', value: 'all' },
+                        { name: jsonMode ? 'Many - Select specific tickets to spawn' : '✅ Many   - Select specific tickets to spawn', value: 'many' },
+                    ],
+                });
+                const resolved = await modeResolver.resolve();
+                // In JSON mode, resolve() exits after outputting prompt, so we never reach here
+                // In interactive mode, we get the selected value
+                spawnMode = resolved.mode;
             }
             let ticketsToSpawn = [];
             if (spawnMode === 'args') {
@@ -240,29 +246,28 @@ export default class WorkSpawn extends PMOCommand {
                 // ALL MODE: Column picker, then spawn all tickets in that column
                 let targetColumn = flags.column;
                 if (!targetColumn) {
-                    // Show columns with ticket counts
-                    const columnChoices = columnNames.map(name => {
-                        const count = allTickets.filter(t => t.statusName === name).length;
-                        return {
-                            name: `${name} (${count} tickets)`,
-                            value: name,
-                        };
+                    // Use FlagResolver for column selection
+                    const columnResolver = new FlagResolver({
+                        commandName: 'work spawn',
+                        baseCommand: 'prlt work spawn --all',
+                        jsonMode,
+                        flags: {},
+                        context: { projectId },
                     });
-                    // In JSON mode, output the column selection prompt
-                    if (jsonMode) {
-                        outputPromptAsJson(buildPromptConfig('list', 'selectedColumn', 'Select column to spawn all tickets tickets from:', columnChoices), createMetadata('work spawn', flags));
-                        db.close();
-                        return;
-                    }
-                    const { selectedColumn } = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'selectedColumn',
-                            message: 'Select column to spawn all tickets tickets from:',
-                            choices: columnChoices,
-                        },
-                    ]);
-                    targetColumn = selectedColumn;
+                    columnResolver.addPrompt({
+                        flagName: 'selectedColumn',
+                        type: 'list',
+                        message: 'Select column to spawn all tickets tickets from:',
+                        choices: () => columnNames.map(name => {
+                            const count = allTickets.filter(t => t.statusName === name).length;
+                            return {
+                                name: `${name} (${count} tickets)`,
+                                value: name,
+                            };
+                        }),
+                    });
+                    const resolved = await columnResolver.resolve();
+                    targetColumn = resolved.selectedColumn;
                 }
                 // Verify column exists
                 const matchedColumn = columnNames.find(c => c.toLowerCase() === targetColumn.toLowerCase());
@@ -288,15 +293,28 @@ export default class WorkSpawn extends PMOCommand {
                 // In JSON mode with --many, output the ticket selection prompt directly
                 // (skip column selection for simplicity - show all tickets)
                 if (jsonMode) {
-                    // Build choices from all tickets tickets
-                    const ticketChoices = allTickets.map(ticket => {
-                        const priority = ticket.priority ? `[${ticket.priority}] ` : '';
-                        return {
-                            name: `${priority}${ticket.id} - ${ticket.title} (${ticket.statusName || 'No Status'})`,
-                            value: ticket.id,
-                        };
+                    // Use FlagResolver for ticket selection in JSON mode
+                    const ticketResolver = new FlagResolver({
+                        commandName: 'work spawn',
+                        baseCommand: 'prlt work spawn',
+                        jsonMode,
+                        flags: {},
+                        context: { projectId },
+                    });
+                    ticketResolver.addPrompt({
+                        flagName: 'selectedTickets',
+                        type: 'checkbox',
+                        message: 'Select tickets to spawn (provide ticket IDs as positional args to execute):',
+                        choices: () => allTickets.map(ticket => {
+                            const priority = ticket.priority ? `[${ticket.priority}] ` : '';
+                            return {
+                                name: `${priority}${ticket.id} - ${ticket.title} (${ticket.statusName || 'No Status'})`,
+                                value: ticket.id,
+                            };
+                        }),
                     });
-                    outputPromptAsJson(buildPromptConfig('checkbox', 'selectedTickets', 'Select tickets to spawn (provide ticket IDs as positional args to execute):', ticketChoices), createMetadata('work spawn', flags));
+                    // In JSON mode, this exits after outputting prompt
+                    await ticketResolver.resolve();
                     db.close();
                     return;
                 }
@@ -311,14 +329,21 @@ export default class WorkSpawn extends PMOCommand {
                         value: name,
                     });
                 }
-                const { manyColumn } = await inquirer.prompt([
-                    {
-                        type: 'list',
-                        name: 'manyColumn',
-                        message: 'Select from which column:',
-                        choices: columnChoices,
-                    },
-                ]);
+                // Use FlagResolver for column selection (many mode)
+                const manyColumnResolver = new FlagResolver({
+                    commandName: 'work spawn',
+                    baseCommand: 'prlt work spawn --many',
+                    jsonMode,
+                    flags: {},
+                });
+                manyColumnResolver.addPrompt({
+                    flagName: 'manyColumn',
+                    type: 'list',
+                    message: 'Select from which column:',
+                    choices: () => columnChoices,
+                });
+                const manyColumnResult = await manyColumnResolver.resolve();
+                const manyColumn = manyColumnResult.manyColumn;
                 // Filter tickets based on column selection
                 const ticketsForSelection = manyColumn === '__ALL__'
                     ? allTickets
@@ -343,6 +368,8 @@ export default class WorkSpawn extends PMOCommand {
                 }
                 // Build choices with priority separators
                 const choices = [];
+                // Also build flat choices for JSON mode (without separators)
+                const flatChoices = [];
                 for (const priority of PRIORITY_ORDER) {
                     const tickets = ticketsByPriority.get(priority) || [];
                     if (tickets.length === 0)
@@ -350,26 +377,35 @@ export default class WorkSpawn extends PMOCommand {
                     choices.push(new inquirer.Separator(`── ${priority} (${tickets.length}) ──`));
                     for (const ticket of tickets) {
                         const statusBadge = ticket.statusName ? ` [${ticket.statusName}]` : '';
-                        choices.push({
+                        const ticketChoice = {
                             name: `[${priority}] ${ticket.id} - ${ticket.title}${statusBadge}`,
                             value: ticket.id,
-                        });
+                        };
+                        choices.push(ticketChoice);
+                        flatChoices.push(ticketChoice);
                     }
                 }
-                const { selectedTicketIds } = await inquirer.prompt([
-                    {
-                        type: 'checkbox',
-                        name: 'selectedTicketIds',
-                        message: 'Select tickets to spawn (space to toggle, enter to confirm):',
-                        choices,
-                        validate: (input) => {
-                            if (input.length === 0) {
-                                return 'Please select at least one ticket';
-                            }
-                            return true;
-                        },
+                // Use FlagResolver for ticket selection (checkbox)
+                const ticketSelectResolver = new FlagResolver({
+                    commandName: 'work spawn',
+                    baseCommand: 'prlt work spawn',
+                    jsonMode,
+                    flags: {},
+                });
+                ticketSelectResolver.addPrompt({
+                    flagName: 'selectedTicketIds',
+                    type: 'checkbox',
+                    message: 'Select tickets to spawn (space to toggle, enter to confirm):',
+                    choices: () => flatChoices,
+                    validate: (input) => {
+                        if (input.length === 0) {
+                            return 'Please select at least one ticket';
+                        }
+                        return true;
                     },
-                ]);
+                });
+                const ticketSelectResult = await ticketSelectResolver.resolve();
+                const selectedTicketIds = ticketSelectResult.selectedTicketIds || [];
                 ticketsToSpawn = allTickets.filter(t => selectedTicketIds.includes(t.id));
                 this.log('');
                 this.log(styles.header(`🚀 Spawn Many: ${ticketsToSpawn.length} tickets`));
@@ -485,15 +521,22 @@ export default class WorkSpawn extends PMOCommand {
                         name: 'adhoc        - Unstructured exploration/debugging',
                         value: '__adhoc__',
                     });
-                    const { selectedAction } = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'selectedAction',
-                            message: 'What action should agents perform?',
-                            choices: actionChoices,
-                            default: 'implement',
-                        },
-                    ]);
+                    // Use FlagResolver for action selection
+                    const actionResolver = new FlagResolver({
+                        commandName: 'work spawn',
+                        baseCommand: 'prlt work spawn',
+                        jsonMode,
+                        flags: {},
+                    });
+                    actionResolver.addPrompt({
+                        flagName: 'selectedAction',
+                        type: 'list',
+                        message: 'What action should agents perform?',
+                        default: 'implement',
+                        choices: () => actionChoices,
+                    });
+                    const actionResult = await actionResolver.resolve();
+                    const selectedAction = actionResult.selectedAction;
                     batchAction = selectedAction === '__adhoc__' ? 'adhoc' : selectedAction;
                 }
                 // Now fetch action details after selection is made
@@ -523,18 +566,25 @@ export default class WorkSpawn extends PMOCommand {
                     const defaultsDescription = modifiesCode
                         ? 'devcontainer, terminal, interactive, safe permissions, create PRs'
                         : 'devcontainer, terminal, interactive, safe permissions, no PRs';
-                    const { useDefaults } = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'useDefaults',
-                            message: `Use default settings for "${actionName}"?`,
-                            choices: [
-                                { name: `✓ Yes - Use defaults (${defaultsDescription})`, value: true },
-                                { name: '✗ No  - Configure each setting', value: false },
-                            ],
-                            default: true,
-                        },
-                    ]);
+                    // Use FlagResolver for defaults choice
+                    const defaultsResolver = new FlagResolver({
+                        commandName: 'work spawn',
+                        baseCommand: 'prlt work spawn',
+                        jsonMode,
+                        flags: {},
+                    });
+                    defaultsResolver.addPrompt({
+                        flagName: 'useDefaults',
+                        type: 'list',
+                        message: `Use default settings for "${actionName}"?`,
+                        default: 'yes',
+                        choices: () => [
+                            { name: `✓ Yes - Use defaults (${defaultsDescription})`, value: 'yes' },
+                            { name: '✗ No  - Configure each setting', value: 'no' },
+                        ],
+                    });
+                    const defaultsResult = await defaultsResolver.resolve();
+                    const useDefaults = defaultsResult.useDefaults === 'yes';
                     if (useDefaults) {
                         // Apply defaults
                         if (hasDevcontainer) {
@@ -574,6 +624,31 @@ export default class WorkSpawn extends PMOCommand {
                             missing.push('devcontainer CLI');
                         devcontainerLabel = `🐳 devcontainer (requires: ${missing.join(', ')})`;
                     }
+                    const envChoices = [
+                        { name: devcontainerLabel, value: 'devcontainer', disabled: !devcontainerReady },
+                        { name: '💻 host (runs directly on your machine)', value: 'host' },
+                        { name: '✗  cancel', value: 'cancel' },
+                    ];
+                    // In JSON mode, use FlagResolver (outputs prompt and exits)
+                    if (jsonMode) {
+                        const envResolver = new FlagResolver({
+                            commandName: 'work spawn',
+                            baseCommand: 'prlt work spawn',
+                            jsonMode,
+                            flags: {},
+                        });
+                        envResolver.addPrompt({
+                            flagName: 'selectedEnvironment',
+                            type: 'list',
+                            message: 'Where should agents run?',
+                            default: devcontainerReady ? 'devcontainer' : 'host',
+                            choices: () => envChoices,
+                        });
+                        await envResolver.resolve();
+                        // FlagResolver exits in JSON mode, so we never reach here
+                        db.close();
+                        return;
+                    }
                     let environmentSelected = false;
                     while (!environmentSelected) {
                         // eslint-disable-next-line no-await-in-loop -- Interactive loop with retry on Docker check
@@ -582,11 +657,7 @@ export default class WorkSpawn extends PMOCommand {
                                 type: 'list',
                                 name: 'selectedEnvironment',
                                 message: 'Where should agents run?',
-                                choices: [
-                                    { name: devcontainerLabel, value: 'devcontainer', disabled: !devcontainerReady },
-                                    { name: '💻 host (runs directly on your machine)', value: 'host' },
-                                    { name: '✗  cancel', value: 'cancel' },
-                                ],
+                                choices: envChoices,
                                 default: devcontainerReady ? 'devcontainer' : 'host',
                             },
                         ]);
@@ -615,32 +686,37 @@ export default class WorkSpawn extends PMOCommand {
                             }
                             // Check GitHub token is available for git push operations
                             if (!isGitHubTokenAvailable()) {
-                                const tokenChoices = [
-                                    { name: 'Yes, continue anyway (git push may fail)', value: 'continue' },
-                                    { name: 'No, let me run gh auth login first', value: 'cancel' },
-                                    { name: 'Switch to host mode instead', value: 'host' },
-                                ];
                                 const tokenMessage = 'GitHub token not found. Git push may fail. Continue without token?';
-                                if (jsonMode) {
-                                    outputPromptAsJson(buildPromptConfig('list', 'tokenAction', tokenMessage, tokenChoices), createMetadata('work spawn', flags));
-                                    db.close();
-                                    return;
+                                // Use FlagResolver for token action prompt
+                                const tokenResolver = new FlagResolver({
+                                    commandName: 'work spawn',
+                                    baseCommand: 'prlt work spawn',
+                                    jsonMode,
+                                    flags: {},
+                                });
+                                tokenResolver.addPrompt({
+                                    flagName: 'tokenAction',
+                                    type: 'list',
+                                    message: tokenMessage,
+                                    default: 'continue',
+                                    choices: () => [
+                                        { name: 'Yes, continue anyway (git push may fail)', value: 'continue' },
+                                        { name: 'No, let me run gh auth login first', value: 'cancel' },
+                                        { name: 'Switch to host mode instead', value: 'host' },
+                                    ],
+                                });
+                                // In JSON mode, this will output prompt and exit
+                                // In interactive mode, show warning first
+                                if (!jsonMode) {
+                                    this.log('');
+                                    this.warn('GitHub token not found.\n' +
+                                        'Git push operations may fail inside containers.\n' +
+                                        'Run `gh auth login` to authenticate, or continue without token.');
+                                    this.log('');
                                 }
-                                this.log('');
-                                this.warn('GitHub token not found.\n' +
-                                    'Git push operations may fail inside containers.\n' +
-                                    'Run `gh auth login` to authenticate, or continue without token.');
-                                this.log('');
                                 // eslint-disable-next-line no-await-in-loop -- Interactive user prompt in loop
-                                const { tokenAction } = await inquirer.prompt([
-                                    {
-                                        type: 'list',
-                                        name: 'tokenAction',
-                                        message: tokenMessage,
-                                        choices: tokenChoices,
-                                        default: 'continue',
-                                    },
-                                ]);
+                                const resolved = await tokenResolver.resolve();
+                                const tokenAction = resolved.tokenAction;
                                 if (tokenAction === 'cancel') {
                                     db.close();
                                     this.log(styles.muted('Run `gh auth login` and try again.'));
@@ -682,18 +758,25 @@ export default class WorkSpawn extends PMOCommand {
                 }
                 // Prompt for display mode if not already set (for host mode without devcontainer)
                 if (!batchDisplay) {
-                    const { selectedMode } = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'selectedMode',
-                            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' },
-                            ],
-                        },
-                    ]);
-                    batchDisplay = selectedMode;
+                    // Use FlagResolver for display mode
+                    const displayResolver = new FlagResolver({
+                        commandName: 'work spawn',
+                        baseCommand: 'prlt work spawn',
+                        jsonMode,
+                        flags: {},
+                    });
+                    displayResolver.addPrompt({
+                        flagName: 'selectedMode',
+                        type: 'list',
+                        message: 'How should agent output be displayed?',
+                        default: 'terminal',
+                        choices: () => [
+                            { name: '🖥️  New tab      - Opens in new terminal tab (recommended)', value: 'terminal' },
+                            { name: '📦 Background  - Runs detached, reattach with: prlt session attach', value: 'background' },
+                        ],
+                    });
+                    const displayResult = await displayResolver.resolve();
+                    batchDisplay = displayResult.selectedMode;
                 }
                 // Default to interactive output mode (streaming UI)
                 // Can be overridden via --output flag if needed
@@ -702,39 +785,51 @@ export default class WorkSpawn extends PMOCommand {
                 }
                 // Prompt for permissions mode if not explicitly set via --skip-permissions flag
                 if (!flags['skip-permissions']) {
-                    const { permissionMode } = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'permissionMode',
-                            message: 'Permission mode for Claude Code:',
-                            choices: [
-                                { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger' },
-                                { name: '🔒 safe   - Requires approval for dangerous operations', value: 'safe' },
-                            ],
-                            default: 'danger',
-                        },
-                    ]);
-                    batchPermissionMode = permissionMode;
+                    // Use FlagResolver for permission mode
+                    const permissionResolver = new FlagResolver({
+                        commandName: 'work spawn',
+                        baseCommand: 'prlt work spawn',
+                        jsonMode,
+                        flags: {},
+                    });
+                    permissionResolver.addPrompt({
+                        flagName: 'permissionMode',
+                        type: 'list',
+                        message: 'Permission mode for Claude Code:',
+                        default: 'danger',
+                        choices: () => [
+                            { name: '⚠️  danger - Skip permission checks (faster, container provides isolation)', value: 'danger' },
+                            { name: '🔒 safe   - Requires approval for dangerous operations', value: 'safe' },
+                        ],
+                    });
+                    const permissionResult = await permissionResolver.resolve();
+                    batchPermissionMode = permissionResult.permissionMode;
                 }
                 // Prompt for PR creation if not provided AND action modifies code
                 // Skip this prompt entirely for non-code-modifying actions (like groom)
                 const actionModifiesCode = selectedActionDetails?.modifiesCode ?? true;
                 if (!batchCreatePr && !batchNoPr) {
                     if (actionModifiesCode) {
-                        const { prChoice } = await inquirer.prompt([
-                            {
-                                type: 'list',
-                                name: 'prChoice',
-                                message: 'Create pull requests when work is ready?',
-                                choices: [
-                                    { name: '✓ Yes - Create PR for each ticket', value: 'yes' },
-                                    { name: '✗ No  - Just move tickets to review', value: 'no' },
-                                ],
-                                default: 'yes',
-                            },
-                        ]);
-                        batchCreatePr = prChoice === 'yes';
-                        batchNoPr = prChoice === 'no';
+                        // 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

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>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     execute(): Promise<void>;