@proletariat/cli 0.3.16 → 0.3.18

package/dist/commands/phase/update.js

@@ -1,9 +1,9 @@
 import { Flags, Args } from '@oclif/core';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { STATE_CATEGORY_ORDER } from '../../lib/pmo/types.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { FlagResolver } from '../../lib/flags/index.js';
 export default class PhaseUpdate extends PMOCommand {
     static description = 'Update a project lifecycle phase';
     static examples = [
@@ -44,10 +44,6 @@ export default class PhaseUpdate extends PMOCommand {
             description: 'Interactive mode',
             default: false,
         }),
-        json: Flags.boolean({
-            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
-            default: false,
-        }),
     };
     getPMOOptions() {
         return { promptIfMultiple: false }; // Phases are workspace-scoped, no project selection needed
@@ -64,47 +60,47 @@ export default class PhaseUpdate extends PMOCommand {
             }
             this.error(message);
         };
-        // Get phase ID - prompt if not provided
+        // Get phase ID - use FlagResolver if not provided
         let phaseId = args.id;
         if (!phaseId) {
             const phases = await this.storage.listPhases();
             if (phases.length === 0) {
                 return handleError('NO_PHASES', 'No phases found. Create a phase first with "prlt phase create".');
             }
-            // In JSON mode, output phase selection prompt
-            if (jsonMode) {
-                const phaseChoices = phases.map(p => ({
+            const idResolver = new FlagResolver({
+                commandName: 'phase update',
+                baseCommand: 'prlt phase update',
+                jsonMode,
+                flags: { machine: flags.machine, json: flags.json },
+            });
+            idResolver.addPrompt({
+                flagName: 'phaseId',
+                type: 'list',
+                message: 'Select phase to update:',
+                choices: () => phases.map(p => ({
                     name: `${p.name} (${p.category})`,
                     value: p.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'phaseId', 'Select phase to update:', phaseChoices), createMetadata('phase update', flags));
-                return;
-            }
-            const { selectedId } = await inquirer.prompt([{
-                    type: 'list',
-                    name: 'selectedId',
-                    message: 'Select phase to update:',
-                    choices: phases.map(p => ({
-                        name: `${p.name} (${p.category})`,
-                        value: p.id,
-                    })),
-                }]);
-            phaseId = selectedId;
+                })),
+                // Use positional arg format for phase ID
+                getCommand: (value) => `prlt phase update ${value} --json`,
+            });
+            const resolved = await idResolver.resolve();
+            phaseId = resolved.phaseId;
         }
         const existing = await this.storage.getPhase(phaseId);
         if (!existing) {
             return handleError('PHASE_NOT_FOUND', `Phase "${phaseId}" not found.`);
         }
-        let updates;
         // Check if any change flags were provided
         const hasChangeFlags = flags.name !== undefined ||
             flags.category !== undefined ||
             flags.color !== undefined ||
             flags.description !== undefined ||
             flags.default !== undefined;
+        let updates;
         // Auto-enter interactive mode if no change flags provided
         if (flags.interactive || !hasChangeFlags) {
-            // Define labels and choices once - single source of truth
+            // Define category labels - single source of truth
             const categoryLabels = {
                 triage: 'Triage - Inbox, needs review',
                 backlog: 'Backlog - Not yet scheduled for work',
@@ -113,22 +109,76 @@ export default class PhaseUpdate extends PMOCommand {
                 completed: 'Completed - Work finished successfully',
                 canceled: 'Canceled - Work won\'t be done',
             };
-            const categoryChoices = STATE_CATEGORY_ORDER.map(cat => ({ name: categoryLabels[cat], value: cat }));
-            // Define fields once - single source of truth for both JSON and interactive modes
-            const fields = [
-                { type: 'input', name: 'name', message: 'Name:', default: existing.name },
-                { type: 'list', name: 'category', message: 'Category:', choices: categoryChoices, default: existing.category },
-                { type: 'input', name: 'color', message: 'Color (hex):', default: existing.color || '' },
-                { type: 'input', name: 'description', message: 'Description:', default: existing.description || '' },
-                { type: 'confirm', name: 'isDefault', message: 'Default for new projects?', default: existing.isDefault || false },
-            ];
-            // In JSON mode, output form prompt
-            if (jsonMode) {
-                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('phase update', flags));
+            // Use FlagResolver for update prompts
+            const resolver = new FlagResolver({
+                commandName: 'phase update',
+                baseCommand: `prlt phase update ${phaseId}`,
+                jsonMode,
+                flags: { machine: flags.machine, json: flags.json },
+            });
+            resolver.addPrompt({
+                flagName: 'name',
+                type: 'input',
+                message: 'Name:',
+                default: existing.name,
+            });
+            resolver.addPrompt({
+                flagName: 'category',
+                type: 'list',
+                message: 'Category:',
+                choices: () => STATE_CATEGORY_ORDER.map(cat => ({
+                    name: categoryLabels[cat],
+                    value: cat,
+                })),
+                default: existing.category,
+                when: (ctx) => ctx.flags.name !== undefined,
+            });
+            resolver.addPrompt({
+                flagName: 'color',
+                type: 'input',
+                message: 'Color (hex):',
+                default: existing.color || '',
+                when: (ctx) => ctx.flags.category !== undefined,
+            });
+            resolver.addPrompt({
+                flagName: 'description',
+                type: 'input',
+                message: 'Description:',
+                default: existing.description || '',
+                when: (ctx) => ctx.flags.color !== undefined,
+            });
+            resolver.addPrompt({
+                flagName: 'isDefault',
+                type: 'list',
+                message: 'Default for new projects?',
+                choices: () => [
+                    { name: 'No', value: false },
+                    { name: 'Yes', value: true },
+                ],
+                default: existing.isDefault || false,
+                when: (ctx) => ctx.flags.description !== undefined,
+            });
+            const resolved = await resolver.resolve();
+            // Build updates from resolved values - only include changed values
+            updates = {};
+            if (resolved.name && resolved.name !== existing.name) {
+                updates.name = resolved.name;
+            }
+            if (resolved.category && resolved.category !== existing.category) {
+                updates.category = resolved.category;
+            }
+            if (resolved.color !== undefined && resolved.color !== (existing.color || '')) {
+                updates.color = resolved.color || undefined;
+            }
+            if (resolved.description !== undefined && resolved.description !== (existing.description || '')) {
+                updates.description = resolved.description || undefined;
+            }
+            if (resolved.isDefault !== undefined && resolved.isDefault !== (existing.isDefault || false)) {
+                updates.isDefault = resolved.isDefault;
             }
-            updates = await this.promptUpdates(fields, existing);
         }
         else {
+            // Use flags directly
             updates = {};
             if (flags.name)
                 updates.name = flags.name;
@@ -155,20 +205,4 @@ export default class PhaseUpdate extends PMOCommand {
             this.log(styles.muted(`  Default: Yes`));
         }
     }
-    async promptUpdates(fields, existing) {
-        // Build inquirer prompts from fields
-        const answers = await inquirer.prompt(fields);
-        const updates = {};
-        if (answers.name !== existing.name)
-            updates.name = answers.name;
-        if (answers.category !== existing.category)
-            updates.category = answers.category;
-        if (answers.color !== (existing.color || ''))
-            updates.color = answers.color || undefined;
-        if (answers.description !== (existing.description || ''))
-            updates.description = answers.description || undefined;
-        if (answers.isDefault !== (existing.isDefault || false))
-            updates.isDefault = answers.isDefault;
-        return updates;
-    }
 }

package/dist/commands/pmo/init.d.ts

@@ -7,6 +7,8 @@ export default class PMOInit extends Command {
         template: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        action: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        confirmation: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
     /**

package/dist/commands/pmo/init.js

@@ -36,6 +36,15 @@ export default class PMOInit extends Command {
             description: 'Output prompt configuration as JSON (for AI agents/scripts)',
             default: false,
         }),
+        action: Flags.string({
+            description: 'Action for existing PMO (cancel or reinitialize)',
+            options: ['cancel', 'reinitialize'],
+            hidden: true,
+        }),
+        confirmation: Flags.string({
+            description: 'Confirmation text for destructive operations',
+            hidden: true,
+        }),
     };
     async run() {
         const { flags } = await this.parse(PMOInit);
@@ -179,6 +188,23 @@ export default class PMOInit extends Command {
         this.log(chalk.green('  ✓ Standalone PMO structure created'));
     }
     findHQRoot() {
+        // Support PRLT_HQ_PATH override (for devcontainers and tests)
+        const hqPathEnv = process.env.PRLT_HQ_PATH;
+        const allowEnvHqPath = process.env.DEVCONTAINER === 'true' || process.env.PRLT_TEST_ENV === 'true';
+        if (hqPathEnv && allowEnvHqPath) {
+            const configPath = path.join(hqPathEnv, '.proletariat', 'config.json');
+            if (fs.existsSync(configPath)) {
+                try {
+                    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                    if (config.type === 'hq') {
+                        return hqPathEnv;
+                    }
+                }
+                catch {
+                    // Fall through to directory walk
+                }
+            }
+        }
         let currentDir = process.cwd();
         while (currentDir !== '/') {
             const configPath = path.join(currentDir, '.proletariat', 'config.json');
@@ -214,38 +240,74 @@ export default class PMOInit extends Command {
         }
         // Define choices once, use for both JSON and interactive modes
         const actionChoices = [
-            { name: 'Cancel (keep existing PMO)', value: 'cancel' },
-            { name: 'Reinitialize (DELETES all data)', value: 'reinitialize' },
+            {
+                name: 'Cancel (keep existing PMO)',
+                value: 'cancel',
+                command: 'prlt pmo init --action cancel --json',
+            },
+            {
+                name: 'Reinitialize (DELETES all data)',
+                value: 'reinitialize',
+                command: 'prlt pmo init --action reinitialize --json',
+            },
         ];
         const message = `PMO already exists at ${pmoPath} (${projectCount} projects, ${ticketCount} tickets). What would you like to do?`;
-        // In JSON mode, output reinitialize prompt and exit
-        if (jsonMode) {
+        // Determine action: from flag, JSON mode, or interactive prompt
+        let action;
+        if (flags.action) {
+            action = flags.action;
+        }
+        else if (jsonMode) {
             outputPromptAsJson(buildPromptConfig('list', 'action', message, actionChoices), createMetadata('pmo init', flags));
+            return null; // unreachable - outputPromptAsJson calls process.exit
+        }
+        else {
+            this.log(chalk.yellow('\n⚠️  PMO already exists'));
+            this.log(chalk.gray(`   Location: ${pmoPath}`));
+            this.log(chalk.gray(`   Projects: ${projectCount}`));
+            this.log(chalk.gray(`   Tickets: ${ticketCount}\n`));
+            const result = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: actionChoices,
+                    default: 'cancel',
+                }]);
+            action = result.action;
         }
-        this.log(chalk.yellow('\n⚠️  PMO already exists'));
-        this.log(chalk.gray(`   Location: ${pmoPath}`));
-        this.log(chalk.gray(`   Projects: ${projectCount}`));
-        this.log(chalk.gray(`   Tickets: ${ticketCount}\n`));
-        const { action } = await inquirer.prompt([{
-                type: 'list',
-                name: 'action',
-                message: 'What would you like to do?',
-                choices: actionChoices,
-                default: 'cancel',
-            }]);
         if (action === 'cancel') {
             return false;
         }
-        // Show warning and require typed confirmation
-        this.log(chalk.red('\n⚠️  WARNING: This will permanently delete:'));
-        this.log(chalk.red('   • All tickets and boards'));
-        this.log(chalk.red('   • All specs and documentation'));
-        this.log(chalk.red('   • Database tables (pmo_*)\n'));
-        const { confirmation } = await inquirer.prompt([{
+        // Determine confirmation: from flag, JSON mode, or interactive prompt
+        let confirmation;
+        if (flags.confirmation) {
+            confirmation = flags.confirmation;
+        }
+        else if (jsonMode) {
+            outputPromptAsJson({
                 type: 'input',
                 name: 'confirmation',
                 message: 'Type "delete pmo" to confirm:',
-            }]);
+                context: {
+                    hint: 'Pass --confirmation "delete pmo" to confirm reinitialize',
+                    example: 'prlt pmo init --action reinitialize --confirmation "delete pmo" --location separate --template kanban --name "my-board" --json',
+                },
+            }, createMetadata('pmo init', flags));
+            return null; // unreachable - outputPromptAsJson calls process.exit
+        }
+        else {
+            // Show warning and require typed confirmation
+            this.log(chalk.red('\n⚠️  WARNING: This will permanently delete:'));
+            this.log(chalk.red('   • All tickets and boards'));
+            this.log(chalk.red('   • All specs and documentation'));
+            this.log(chalk.red('   • Database tables (pmo_*)\n'));
+            const result = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'confirmation',
+                    message: 'Type "delete pmo" to confirm:',
+                }]);
+            confirmation = result.confirmation;
+        }
         if (confirmation !== 'delete pmo') {
             this.log(chalk.yellow('\nCancelled. Confirmation text did not match.'));
             return false;

package/dist/commands/pr/create.d.ts

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-export default class PRCreate extends Command {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class PRCreate extends PMOCommand {
     static description: string;
     static examples: string[];
     static args: {
@@ -11,7 +11,16 @@ export default class PRCreate extends Command {
         'no-link': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         title: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         body: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        ticket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<void>;
+    private hasPMO;
+    /**
+     * Override init to gracefully handle missing PMO
+     * PR creation should work even without PMO (just without ticket linking)
+     */
+    init(): Promise<void>;
+    execute(): Promise<void>;
 }