@proletariat/cli 0.3.105 → 0.3.110

package/dist/commands/work/start.js

@@ -112,6 +112,46 @@ function mergeAllowlists(actionDomains, flagValue) {
 function isIssueSource(value) {
     return value === 'linear' || value === 'jira' || value === 'asana' || value === 'shortcut' || value === 'trello';
 }
+/**
+ * Extract explicitly-set flags for JSON mode command chaining.
+ * Filters out defaults (false/undefined) and the json flag itself.
+ * Used as accumulatedFlags so buildCommand includes prior resolver results.
+ */
+function getAccumulatedFlags(flags) {
+    const result = {};
+    for (const [key, val] of Object.entries(flags)) {
+        if (key === 'json' || val === undefined || val === false)
+            continue;
+        result[key] = val;
+    }
+    return result;
+}
+/**
+ * Build a base command string with all explicitly-set flags for JSON mode chaining.
+ * Used by getCommand callbacks to include accumulated flags from prior prompts.
+ */
+function buildJsonBase(ticketId, flags) {
+    let cmd = `prlt work start ${ticketId}`;
+    for (const [key, val] of Object.entries(flags)) {
+        if (key === 'json' || val === undefined || val === false)
+            continue;
+        if (typeof val === 'boolean') {
+            cmd += ` --${key}`;
+        }
+        else if (typeof val === 'string') {
+            cmd += ` --${key} "${val}"`;
+        }
+        else if (Array.isArray(val)) {
+            for (const item of val) {
+                cmd += ` --${key} "${item}"`;
+            }
+        }
+        else {
+            cmd += ` --${key} ${val}`;
+        }
+    }
+    return cmd;
+}
 function buildExternalMetadata(envelope) {
     switch (envelope.source.name) {
         case 'jira': return buildJiraMetadata(envelope);
@@ -329,6 +369,10 @@ export default class WorkStart extends PMOCommand {
             description: 'Validate environment and prerequisites without actually spawning an agent',
             default: false,
         }),
+        environment: Flags.string({
+            description: 'Execution environment (devcontainer or host). Use to bypass the environment selection prompt.',
+            options: ['devcontainer', 'host'],
+        }),
     };
     async findLinkedTicketByEnvelope(_projectId, envelope) {
         // Ticket lives in the provider (Linear, etc.) — look it up directly, no local PMO scan
@@ -471,6 +515,10 @@ export default class WorkStart extends PMOCommand {
         if (flags['skip-permissions']) {
             flags['permission-mode'] = 'danger';
         }
+        // Handle --environment flag: normalize to --run-on-host for host mode
+        if (flags.environment === 'host') {
+            flags['run-on-host'] = true;
+        }
         // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
         const jsonModeConfig = jsonMode ? { flags: flags, commandName: 'work start' } : null;
@@ -843,7 +891,9 @@ export default class WorkStart extends PMOCommand {
                     baseCommand: `prlt work start ${ticketId}`,
                     jsonMode,
                     flags: {},
+                    accumulatedFlags: getAccumulatedFlags(flags),
                 });
+                const jsonBaseBlocked = buildJsonBase(ticketId, flags);
                 blockedResolver.addPrompt({
                     flagName: 'startAnyway',
                     type: 'list',
@@ -853,6 +903,11 @@ export default class WorkStart extends PMOCommand {
                         { name: 'No, cancel', value: 'no' },
                         { name: 'Yes, start despite blockers', value: 'yes' },
                     ],
+                    getCommand: (value) => {
+                        if (value === 'yes')
+                            return `${jsonBaseBlocked} --force --json`;
+                        return '';
+                    },
                 });
                 const blockedResult = await blockedResolver.resolve();
                 if (blockedResult.startAnyway !== 'yes') {
@@ -873,10 +928,11 @@ export default class WorkStart extends PMOCommand {
                     commandName: 'work start',
                     baseCommand: `prlt work start ${ticketId}`,
                     jsonMode,
-                    flags: flags['session-action'] ? { sessionAction: flags['session-action'] } : {},
+                    flags: flags['session-action'] ? { 'session-action': flags['session-action'] } : {},
+                    accumulatedFlags: getAccumulatedFlags(flags),
                 });
                 sessionResolver.addPrompt({
-                    flagName: 'sessionAction',
+                    flagName: 'session-action',
                     type: 'list',
                     message: 'What would you like to do?',
                     choices: () => [
@@ -887,7 +943,7 @@ export default class WorkStart extends PMOCommand {
                     ],
                 });
                 const sessionResult = await sessionResolver.resolve();
-                const sessionAction = sessionResult.sessionAction;
+                const sessionAction = sessionResult['session-action'];
                 if (sessionAction === 'cancel') {
                     db.close();
                     this.log(styles.muted('Cancelled.'));
@@ -1033,11 +1089,13 @@ export default class WorkStart extends PMOCommand {
                         agentChoiceList.push({ name: `${a.name} (working on ${ticketIds})`, value: a.name, disabled: true });
                     }
                     // Use FlagResolver for agent selection
+                    const jsonBaseAgent = buildJsonBase(ticketId, flags);
                     const agentResolver = new FlagResolver({
                         commandName: 'work start',
                         baseCommand: `prlt work start ${ticketId}`,
                         jsonMode,
                         flags: {},
+                        accumulatedFlags: getAccumulatedFlags(flags),
                     });
                     agentResolver.addPrompt({
                         flagName: 'selectedAgent',
@@ -1045,6 +1103,11 @@ export default class WorkStart extends PMOCommand {
                         message: `Select agent for ${ticketId}:`,
                         default: '__ephemeral__',
                         choices: () => agentChoiceList,
+                        getCommand: (value) => {
+                            if (value === '__ephemeral__')
+                                return `${jsonBaseAgent} --ephemeral --json`;
+                            return `${jsonBaseAgent} --agent "${value}" --json`;
+                        },
                     });
                     const agentResult = await agentResolver.resolve();
                     const selectedAgent = agentResult.selectedAgent;
@@ -1151,11 +1214,13 @@ export default class WorkStart extends PMOCommand {
                         this.log('');
                     }
                     // Use FlagResolver for unsaved work action
+                    const jsonBaseUnsaved = buildJsonBase(ticketId, flags);
                     const unsavedResolver = new FlagResolver({
                         commandName: 'work start',
                         baseCommand: `prlt work start ${ticketId}`,
                         jsonMode,
                         flags: {},
+                        accumulatedFlags: getAccumulatedFlags(flags),
                     });
                     unsavedResolver.addPrompt({
                         flagName: 'unsavedAction',
@@ -1166,6 +1231,12 @@ export default class WorkStart extends PMOCommand {
                             { name: 'Continue anyway (existing work may conflict)', value: 'continue' },
                             { name: 'Cancel', value: 'cancel' },
                         ],
+                        getCommand: (value) => {
+                            if (value === 'cancel')
+                                return '';
+                            // Both 'push' and 'continue' advance; use --force to skip re-prompt
+                            return `${jsonBaseUnsaved} --force --json`;
+                        },
                     });
                     const unsavedResult = await unsavedResolver.resolve();
                     const action = unsavedResult.unsavedAction;
@@ -1262,12 +1333,13 @@ export default class WorkStart extends PMOCommand {
             // Check if agent has devcontainer config
             const hasDevcontainer = hasDevcontainerConfig(agentDir);
             // Use devcontainer by default if available, unless --run-on-host is set
-            const useDevcontainer = hasDevcontainer && !flags['run-on-host'];
+            // --environment devcontainer explicitly requests devcontainer mode
+            const useDevcontainer = (hasDevcontainer && !flags['run-on-host']) || flags.environment === 'devcontainer';
             // Determine execution environment and display mode
             let environment = 'host';
             let displayMode = 'terminal';
             let permissionMode = 'danger';
-            if (hasDevcontainer && !flags.display && !flags['run-on-host']) {
+            if (hasDevcontainer && !flags.display && !flags['run-on-host'] && !flags.environment) {
                 // Agent has devcontainer - prompt for environment choice
                 const devcontainerLabel = '🐳 devcontainer (isolated, recommended)';
                 const envChoices = [
@@ -1277,11 +1349,13 @@ export default class WorkStart extends PMOCommand {
                 ];
                 // In JSON mode, use FlagResolver (outputs prompt and exits)
                 if (jsonMode) {
+                    const jsonBaseEnv = buildJsonBase(ticketId, flags);
                     const envResolver = new FlagResolver({
                         commandName: 'work start',
                         baseCommand: `prlt work start ${ticketId}`,
                         jsonMode,
                         flags: {},
+                        accumulatedFlags: getAccumulatedFlags(flags),
                     });
                     envResolver.addPrompt({
                         flagName: 'environment',
@@ -1290,13 +1364,12 @@ export default class WorkStart extends PMOCommand {
                         default: 'devcontainer',
                         choices: () => envChoices,
                         getCommand: (value) => {
-                            const base = `prlt work start ${ticketId}`;
                             if (value === 'host')
-                                return `${base} --run-on-host --json`;
+                                return `${jsonBaseEnv} --run-on-host --json`;
                             if (value === 'cancel')
                                 return '';
-                            // devcontainer is the default when available
-                            return `${base} --json`;
+                            // Explicit --environment devcontainer so the command advances past this prompt
+                            return `${jsonBaseEnv} --environment devcontainer --json`;
                         },
                     });
                     await envResolver.resolve();
@@ -1343,11 +1416,13 @@ export default class WorkStart extends PMOCommand {
                         if (!isGitHubTokenAvailable()) {
                             const tokenMessage = 'GitHub token not found. Git push may fail. Continue without token?';
                             // Use FlagResolver for token action prompt
+                            const jsonBaseToken = buildJsonBase(ticketId, flags);
                             const tokenResolver = new FlagResolver({
                                 commandName: 'work start',
                                 baseCommand: `prlt work start ${ticketId}`,
                                 jsonMode,
                                 flags: {},
+                                accumulatedFlags: getAccumulatedFlags(flags),
                             });
                             tokenResolver.addPrompt({
                                 flagName: 'tokenAction',
@@ -1359,6 +1434,14 @@ export default class WorkStart extends PMOCommand {
                                     { name: 'No, let me run gh auth login first', value: 'cancel' },
                                     { name: 'Switch to host mode instead', value: 'host' },
                                 ],
+                                getCommand: (value) => {
+                                    if (value === 'cancel')
+                                        return '';
+                                    if (value === 'host')
+                                        return `${jsonBaseToken} --run-on-host --json`;
+                                    // 'continue' — re-run with environment devcontainer explicit
+                                    return `${jsonBaseToken} --environment devcontainer --json`;
+                                },
                             });
                             // In JSON mode, this will output prompt and exit
                             // In interactive mode, show warning first then prompt
@@ -1469,9 +1552,10 @@ export default class WorkStart extends PMOCommand {
                         baseCommand: `prlt work start ${ticketId}`,
                         jsonMode,
                         flags: {},
+                        accumulatedFlags: getAccumulatedFlags(flags),
                     });
                     displayResolver.addPrompt({
-                        flagName: 'selectedMode',
+                        flagName: 'display',
                         type: 'list',
                         message: warningMsg,
                         default: 'terminal',
@@ -1482,7 +1566,7 @@ export default class WorkStart extends PMOCommand {
                         ],
                     });
                     const displayResult = await displayResolver.resolve();
-                    displayMode = displayResult.selectedMode;
+                    displayMode = displayResult.display;
                 }
             }
             const executor = flags.executor || DEFAULT_EXECUTION_CONFIG.defaultExecutor;
@@ -1513,17 +1597,24 @@ export default class WorkStart extends PMOCommand {
                             { name: '✗  Cancel', value: 'cancel' },
                         ];
                         const dockerMessage = 'Docker is not running. What would you like to do?';
+                        const jsonBaseDocker = buildJsonBase(ticketId, flags);
                         const dockerResolver = new FlagResolver({
                             commandName: 'work start',
                             baseCommand: `prlt work start ${ticketId}`,
                             jsonMode,
                             flags: {},
+                            accumulatedFlags: getAccumulatedFlags(flags),
                         });
                         dockerResolver.addPrompt({
                             flagName: 'dockerAction',
                             type: 'list',
                             message: dockerMessage,
                             choices: () => dockerChoices,
+                            getCommand: (value) => {
+                                if (value === 'host')
+                                    return `${jsonBaseDocker} --run-on-host --json`;
+                                return '';
+                            },
                         });
                         const dockerResult = await dockerResolver.resolve();
                         const dockerAction = dockerResult.dockerAction;
@@ -1601,17 +1692,29 @@ export default class WorkStart extends PMOCommand {
                                 }
                                 authChoices.push({ name: '💻 Switch to host environment instead', value: 'host' }, { name: '✗  Cancel', value: 'cancel' });
                                 // Use FlagResolver for auth method selection
+                                const jsonBaseAuth = buildJsonBase(ticketId, flags);
                                 const authResolver = new FlagResolver({
                                     commandName: 'work start',
                                     baseCommand: `prlt work start ${ticketId}`,
                                     jsonMode,
                                     flags: {},
+                                    accumulatedFlags: getAccumulatedFlags(flags),
                                 });
                                 authResolver.addPrompt({
                                     flagName: 'authAction',
                                     type: 'list',
                                     message: 'How should the agent authenticate with Claude?',
                                     choices: () => authChoices,
+                                    getCommand: (value) => {
+                                        if (value === 'apikey')
+                                            return `${jsonBaseAuth} --use-api-key --json`;
+                                        if (value === 'host')
+                                            return `${jsonBaseAuth} --run-on-host --json`;
+                                        if (value === 'cancel')
+                                            return '';
+                                        // oauth — re-run with environment devcontainer (requires interactive auth flow)
+                                        return `${jsonBaseAuth} --environment devcontainer --json`;
+                                    },
                                 });
                                 const authResult = await authResolver.resolve();
                                 const authAction = authResult.authAction;
@@ -1695,6 +1798,7 @@ export default class WorkStart extends PMOCommand {
                                         baseCommand: `prlt work start ${ticketId}`,
                                         jsonMode,
                                         flags: {},
+                                        accumulatedFlags: getAccumulatedFlags(flags),
                                     });
                                     saveResolver.addPrompt({
                                         flagName: 'saveDefault',
@@ -1743,6 +1847,7 @@ export default class WorkStart extends PMOCommand {
                     baseCommand: `prlt work start ${ticketId}`,
                     jsonMode,
                     flags: { 'permission-mode': flags['permission-mode'] },
+                    accumulatedFlags: getAccumulatedFlags(flags),
                 });
                 const executorName = getExecutorDisplayName(executor);
                 permissionResolver.addPrompt({
@@ -1791,11 +1896,13 @@ export default class WorkStart extends PMOCommand {
                 }
                 else {
                     // Use FlagResolver for PR choice
+                    const jsonBasePr = buildJsonBase(ticketId, flags);
                     const prResolver = new FlagResolver({
                         commandName: 'work start',
                         baseCommand: `prlt work start ${ticketId}`,
                         jsonMode,
                         flags: {},
+                        accumulatedFlags: getAccumulatedFlags(flags),
                     });
                     prResolver.addPrompt({
                         flagName: 'prChoice',
@@ -1806,6 +1913,11 @@ export default class WorkStart extends PMOCommand {
                             { name: '✓ Yes - Create PR when running `prlt work ready`', value: 'yes' },
                             { name: '✗ No  - Just move ticket to review (can create PR later)', value: 'no' },
                         ],
+                        getCommand: (value) => {
+                            if (value === 'yes')
+                                return `${jsonBasePr} --create-pr --json`;
+                            return `${jsonBasePr} --json`;
+                        },
                     });
                     const prResult = await prResolver.resolve();
                     createPR = prResult.prChoice === 'yes';
@@ -1918,8 +2030,9 @@ export default class WorkStart extends PMOCommand {
                     // Ticket already has a branch linked - just use it
                     this.log(styles.muted(`Using existing branch: ${branch}`));
                 }
-                else if (flags.action || flags.force) {
-                    // Non-interactive mode (spawned from batch command) - auto-create branch
+                else if (flags.action || flags.force || jsonMode) {
+                    // Non-interactive / JSON mode - auto-create branch
+                    // JSON mode agents can't interactively enter branch names
                     finalBranch = branch;
                     this.log(styles.muted(`Branch: ${finalBranch}`));
                 }