@proletariat/cli 0.3.16 → 0.3.18

package/dist/commands/status/move.js

@@ -1,8 +1,8 @@
 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 { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { FlagResolver, shouldOutputJson } from '../../lib/flags/index.js';
+import { outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class StatusMove extends PMOCommand {
     static description = 'Reorder a status within its category';
     static examples = [
@@ -18,10 +18,6 @@ export default class StatusMove extends PMOCommand {
     };
     static flags = {
         ...pmoBaseFlags,
-        json: Flags.boolean({
-            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
-            default: false,
-        }),
         position: Flags.integer({
             char: 'p',
             description: 'New position (0-indexed) within the category',
@@ -30,10 +26,16 @@ export default class StatusMove extends PMOCommand {
     };
     async execute() {
         const { args, flags } = await this.parse(StatusMove);
-        // 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 - get projectId (with JSON mode support)
+        const projectId = await this.requireProject({
+            jsonMode: jsonMode ? {
+                flags,
+                commandName: 'status move',
+                baseCommand: 'prlt status move',
+            } : undefined,
+        });
         // Helper to handle errors in JSON mode
         const handleError = (code, message) => {
             if (jsonMode) {
@@ -47,65 +49,64 @@ export default class StatusMove extends PMOCommand {
         if (!project?.workflowId) {
             return handleError('NO_WORKFLOW', `Project "${projectId}" has no workflow assigned.`);
         }
-        // Get status ID - prompt if not provided
-        let statusId = args.id;
-        if (!statusId) {
-            const statuses = await this.storage.listStatuses(project.workflowId);
-            if (statuses.length === 0) {
-                return handleError('NO_STATUSES', 'No statuses found. Create a status first with "prlt status create".');
-            }
-            // In JSON mode, output status selection prompt
-            if (jsonMode) {
-                const statusChoices = statuses.map(s => ({
-                    name: `${s.name} (${s.category}, position ${s.position})`,
-                    value: s.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select status to move:', statusChoices), createMetadata('status move', flags));
-                return;
-            }
-            const { selectedId } = await inquirer.prompt([{
-                    type: 'list',
-                    name: 'selectedId',
-                    message: 'Select status to move:',
-                    choices: statuses.map(s => ({
-                        name: `${s.name} (${s.category}, position ${s.position})`,
-                        value: s.id,
-                    })),
-                }]);
-            statusId = selectedId;
+        // Get all statuses for this workflow
+        const statuses = await this.storage.listStatuses(project.workflowId);
+        if (statuses.length === 0) {
+            return handleError('NO_STATUSES', 'No statuses found. Create a status first with "prlt status create".');
         }
+        // Create FlagResolver for prompts
+        const resolver = new FlagResolver({
+            commandName: 'status move',
+            baseCommand: 'prlt status move',
+            jsonMode,
+            flags: { ...flags, id: args.id },
+            context: { projectId },
+        });
+        // Add status selection prompt
+        resolver.addPrompt({
+            flagName: 'id',
+            type: 'list',
+            message: 'Select status to move:',
+            choices: () => statuses.map(s => ({
+                name: `${s.name} (${s.category}, position ${s.position})`,
+                value: s.id,
+                command: `prlt status move ${s.id} --machine`,
+            })),
+            when: (ctx) => !ctx.flags.id,
+        });
+        // Resolve status ID
+        const resolved = await resolver.resolve();
+        const statusId = resolved.id;
         // Get existing status
         const existing = await this.storage.getStatus(statusId);
         if (!existing) {
             return handleError('STATUS_NOT_FOUND', `Status not found: ${statusId}`);
         }
-        // Get position - prompt if not provided
-        let newPosition = flags.position;
-        if (newPosition === undefined) {
-            // Get statuses in the same category to show valid positions
-            const statuses = await this.storage.listStatuses(project.workflowId);
-            const categoryStatuses = statuses.filter(s => s.category === existing.category);
-            // In JSON mode, output position selection prompt
-            if (jsonMode) {
-                const positionChoices = categoryStatuses.map((_, idx) => ({
-                    name: `Position ${idx}${idx === existing.position ? ' (current)' : ''}`,
-                    value: String(idx),
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'position', `New position within ${existing.category} (currently ${existing.position}):`, positionChoices), createMetadata('status move', flags));
-                return;
-            }
-            const { position } = await inquirer.prompt([{
-                    type: 'list',
-                    name: 'position',
-                    message: `New position within ${existing.category} (currently ${existing.position}):`,
-                    choices: categoryStatuses.map((_, idx) => ({
-                        name: `Position ${idx}${idx === existing.position ? ' (current)' : ''}`,
-                        value: idx,
-                    })),
-                    default: existing.position,
-                }]);
-            newPosition = position;
-        }
+        // Get statuses in the same category for position selection
+        const categoryStatuses = statuses.filter(s => s.category === existing.category);
+        // Create second resolver for position (needs status context)
+        const positionResolver = new FlagResolver({
+            commandName: 'status move',
+            baseCommand: 'prlt status move',
+            jsonMode,
+            flags: { ...flags, id: statusId },
+            context: { projectId, statusId, existing },
+        });
+        // Add position selection prompt
+        positionResolver.addPrompt({
+            flagName: 'position',
+            type: 'list',
+            message: `New position within ${existing.category} (currently ${existing.position}):`,
+            choices: () => categoryStatuses.map((_, idx) => ({
+                name: `Position ${idx}${idx === existing.position ? ' (current)' : ''}`,
+                value: idx,
+                command: `prlt status move ${statusId} --position ${idx} --machine`,
+            })),
+            when: (ctx) => ctx.flags.position === undefined,
+        });
+        // Resolve position
+        const positionResolved = await positionResolver.resolve();
+        const newPosition = positionResolved.position;
         if (newPosition < 0) {
             this.error('Position must be >= 0');
         }

package/dist/commands/status/update.d.ts

@@ -6,15 +6,15 @@ export default class StatusUpdate extends PMOCommand {
         id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
-        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         category: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         color: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         default: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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>;
     };
     execute(): Promise<void>;
-    private promptChanges;
 }

package/dist/commands/status/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 { FlagResolver, shouldOutputJson } from '../../lib/flags/index.js';
+import { outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class StatusUpdate extends PMOCommand {
     static description = 'Update a workflow status';
     static examples = [
@@ -20,10 +20,6 @@ export default class StatusUpdate extends PMOCommand {
     };
     static flags = {
         ...pmoBaseFlags,
-        json: Flags.boolean({
-            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
-            default: false,
-        }),
         name: Flags.string({
             char: 'n',
             description: 'New status name',
@@ -52,10 +48,16 @@ export default class StatusUpdate extends PMOCommand {
     };
     async execute() {
         const { args, flags } = await this.parse(StatusUpdate);
-        // 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 - get projectId (with JSON mode support)
+        const projectId = await this.requireProject({
+            jsonMode: jsonMode ? {
+                flags,
+                commandName: 'status update',
+                baseCommand: 'prlt status update',
+            } : undefined,
+        });
         // Helper to handle errors in JSON mode
         const handleError = (code, message) => {
             if (jsonMode) {
@@ -69,62 +71,120 @@ export default class StatusUpdate extends PMOCommand {
         if (!project?.workflowId) {
             return handleError('NO_WORKFLOW', `Project "${projectId}" has no workflow assigned.`);
         }
-        // Get status ID - prompt if not provided
-        let statusId = args.id;
-        if (!statusId) {
-            const statuses = await this.storage.listStatuses(project.workflowId);
-            if (statuses.length === 0) {
-                return handleError('NO_STATUSES', 'No statuses found. Create a status first with "prlt status create".');
-            }
-            // In JSON mode, output status selection prompt
-            if (jsonMode) {
-                const statusChoices = statuses.map(s => ({
-                    name: `${s.name} (${s.category})`,
-                    value: s.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select status to update:', statusChoices), createMetadata('status update', flags));
-                return;
-            }
-            const { selectedId } = await inquirer.prompt([{
-                    type: 'list',
-                    name: 'selectedId',
-                    message: 'Select status to update:',
-                    choices: statuses.map(s => ({
-                        name: `${s.name} (${s.category})`,
-                        value: s.id,
-                    })),
-                }]);
-            statusId = selectedId;
+        // Get all statuses for this workflow
+        const statuses = await this.storage.listStatuses(project.workflowId);
+        if (statuses.length === 0) {
+            return handleError('NO_STATUSES', 'No statuses found. Create a status first with "prlt status create".');
         }
+        // Create FlagResolver for status selection
+        const resolver = new FlagResolver({
+            commandName: 'status update',
+            baseCommand: 'prlt status update',
+            jsonMode,
+            flags: { ...flags, id: args.id, category: flags.category },
+            context: { projectId },
+        });
+        // Add status selection prompt
+        resolver.addPrompt({
+            flagName: 'id',
+            type: 'list',
+            message: 'Select status to update:',
+            choices: () => statuses.map(s => ({
+                name: `${s.name} (${s.category})`,
+                value: s.id,
+                command: `prlt status update ${s.id} --machine`,
+            })),
+            when: (ctx) => !ctx.flags.id,
+        });
+        // Resolve status ID
+        const resolved = await resolver.resolve();
+        const statusId = resolved.id;
         // Get existing status
         const existing = await this.storage.getStatus(statusId);
         if (!existing) {
             return handleError('STATUS_NOT_FOUND', `Status not found: ${statusId}`);
         }
-        let changes;
         // 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 changes;
         // Auto-enter interactive mode if no change flags provided
         if (flags.interactive || !hasChangeFlags) {
-            // Build choices once - single source of truth
-            const categoryChoices = STATE_CATEGORY_ORDER.map(cat => ({ name: cat, value: cat }));
-            // Define fields once - single source of truth for both JSON and interactive modes
-            const fields = [
-                { type: 'input', name: 'name', message: 'Status name:', default: existing.name },
-                { type: 'list', name: 'category', message: 'Category:', choices: categoryChoices, default: existing.category },
-                { type: 'input', name: 'color', message: 'Color (hex, optional):', default: existing.color || '' },
-                { type: 'input', name: 'description', message: 'Description (optional):', default: existing.description || '' },
-                { type: 'confirm', name: 'isDefault', message: 'Set as default status for new tickets?', default: existing.isDefault || false },
-            ];
-            // In JSON mode, output form prompts
-            if (jsonMode) {
-                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('status update', flags));
-            }
-            changes = await this.promptChanges(fields, existing);
+            // Create FlagResolver for field updates
+            const updateResolver = new FlagResolver({
+                commandName: 'status update',
+                baseCommand: `prlt status update ${statusId}`,
+                jsonMode,
+                flags: { ...flags, id: statusId, category: flags.category },
+                context: { projectId, statusId, existing },
+            });
+            // Add prompts for each field
+            updateResolver.addPrompt({
+                flagName: 'name',
+                type: 'input',
+                message: 'Status name:',
+                default: existing.name,
+                validate: (value) => value.length > 0 || 'Name is required',
+                when: (ctx) => ctx.flags.name === undefined,
+            });
+            updateResolver.addPrompt({
+                flagName: 'category',
+                type: 'list',
+                message: 'Category:',
+                choices: () => STATE_CATEGORY_ORDER.map(cat => ({
+                    name: cat,
+                    value: cat,
+                    command: `prlt status update ${statusId} --category ${cat} --machine`,
+                })),
+                default: existing.category,
+                when: (ctx) => ctx.flags.category === undefined,
+            });
+            updateResolver.addPrompt({
+                flagName: 'color',
+                type: 'input',
+                message: 'Color (hex, optional):',
+                default: existing.color || '',
+                validate: (value) => {
+                    const v = value;
+                    if (!v)
+                        return true;
+                    return /^#[0-9A-Fa-f]{6}$/.test(v) || 'Invalid hex color (e.g., #FF0000)';
+                },
+                when: (ctx) => ctx.flags.color === undefined,
+            });
+            updateResolver.addPrompt({
+                flagName: 'description',
+                type: 'input',
+                message: 'Description (optional):',
+                default: existing.description || '',
+                when: (ctx) => ctx.flags.description === undefined,
+            });
+            updateResolver.addPrompt({
+                flagName: 'default',
+                type: 'list',
+                message: 'Set as default status for new tickets?',
+                choices: () => [
+                    { name: 'Yes', value: true, command: `prlt status update ${statusId} --default --json` },
+                    { name: 'No', value: false, command: `prlt status update ${statusId} --no-default --json` },
+                ],
+                default: existing.isDefault || false,
+                when: (ctx) => ctx.flags.default === undefined,
+            });
+            const updateResolved = await updateResolver.resolve();
+            changes = {};
+            if (updateResolved.name !== existing.name)
+                changes.name = updateResolved.name;
+            if (updateResolved.category !== existing.category)
+                changes.category = updateResolved.category;
+            if (updateResolved.color !== (existing.color || ''))
+                changes.color = updateResolved.color || undefined;
+            if (updateResolved.description !== (existing.description || ''))
+                changes.description = updateResolved.description || undefined;
+            if (updateResolved.default !== (existing.isDefault || false))
+                changes.isDefault = updateResolved.default;
         }
         else {
             changes = {};
@@ -150,31 +210,4 @@ export default class StatusUpdate extends PMOCommand {
             this.log(styles.muted(`  Default: yes`));
         }
     }
-    async promptChanges(fields, existing) {
-        // Build inquirer prompts from fields, adding validators
-        const answers = await inquirer.prompt(fields.map(field => ({
-            ...field,
-            validate: field.name === 'name'
-                ? ((input) => input.length > 0 || 'Name is required')
-                : field.name === 'color'
-                    ? ((input) => {
-                        if (!input)
-                            return true;
-                        return /^#[0-9A-Fa-f]{6}$/.test(input) || 'Invalid hex color (e.g., #FF0000)';
-                    })
-                    : undefined,
-        })));
-        const changes = {};
-        if (answers.name !== existing.name)
-            changes.name = answers.name;
-        if (answers.category !== existing.category)
-            changes.category = answers.category;
-        if (answers.color !== (existing.color || ''))
-            changes.color = answers.color || undefined;
-        if (answers.description !== (existing.description || ''))
-            changes.description = answers.description || undefined;
-        if (answers.isDefault !== (existing.isDefault || false))
-            changes.isDefault = answers.isDefault;
-        return changes;
-    }
 }

package/dist/commands/template/delete.d.ts

@@ -6,6 +6,7 @@ export default class TemplateDelete extends PMOCommand {
         type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: 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>;
     };
     protected getPMOOptions(): {

package/dist/commands/template/delete.js

@@ -1,8 +1,8 @@
 import { Flags } from '@oclif/core';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { FlagResolver, shouldOutputJson } from '../../lib/flags/index.js';
+import { outputErrorAsJson, createMetadata } from '../../lib/prompt-json.js';
 export default class TemplateDelete extends PMOCommand {
     static description = 'Delete templates (ticket or phase)';
     static examples = [
@@ -33,28 +33,28 @@ export default class TemplateDelete extends PMOCommand {
     }
     async execute() {
         const { flags } = await this.parse(TemplateDelete);
-        // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
-        // If no type specified, prompt for type first
-        let templateType = flags.type;
-        if (!templateType) {
-            const typeChoices = [
-                { name: 'Ticket templates', value: 'ticket' },
-                { name: 'Phase templates', value: 'phase' },
-            ];
-            const typeMessage = 'Which template type would you like to delete?';
-            if (jsonMode) {
-                outputPromptAsJson(buildPromptConfig('list', 'type', typeMessage, typeChoices), createMetadata('template delete', flags));
-                return;
-            }
-            const { selectedType } = await inquirer.prompt([{
-                    type: 'list',
-                    name: 'selectedType',
-                    message: typeMessage,
-                    choices: typeChoices,
-                }]);
-            templateType = selectedType;
-        }
+        // Create resolver for type and template selection
+        const resolver = new FlagResolver({
+            commandName: 'template delete',
+            baseCommand: 'prlt template delete',
+            jsonMode,
+            flags,
+        });
+        // Prompt for template type if not provided
+        resolver.addPrompt({
+            flagName: 'type',
+            type: 'list',
+            message: 'Which template type would you like to delete?',
+            choices: () => [
+                { name: 'Ticket templates', value: 'ticket', command: 'prlt template delete --type ticket --json' },
+                { name: 'Phase templates', value: 'phase', command: 'prlt template delete --type phase --json' },
+            ],
+            when: (ctx) => !ctx.flags.type,
+        });
+        // First resolve type
+        const resolvedType = await resolver.resolve();
+        const templateType = resolvedType.type;
         // Get custom templates of the selected type
         let templates = [];
         let typeName = '';
@@ -75,45 +75,44 @@ export default class TemplateDelete extends PMOCommand {
         if (templates.length === 0) {
             if (jsonMode) {
                 outputErrorAsJson('NO_TEMPLATES', `No custom ${typeName} templates to delete.`, createMetadata('template delete', flags));
-                this.exit(1);
             }
             this.log(styles.muted(`\nNo custom ${typeName} templates to delete.`));
             return;
         }
-        // Build choices for template selection
-        const templateChoices = templates.map(t => ({
-            name: t.name,
-            value: t.id,
-        }));
-        const message = `Select ${typeName} templates to delete:`;
-        // In JSON mode, output template selection prompt
-        if (jsonMode) {
-            outputPromptAsJson(buildPromptConfig('checkbox', 'templateIds', message, templateChoices), createMetadata('template delete', flags));
-            return;
-        }
-        // Select templates to delete
-        const { selected } = await inquirer.prompt([{
-                type: 'checkbox',
-                name: 'selected',
-                message,
-                choices: templateChoices,
-            }]);
+        // Create new resolver for template selection (needs templates data)
+        const templateResolver = new FlagResolver({
+            commandName: 'template delete',
+            baseCommand: 'prlt template delete',
+            jsonMode,
+            flags: {},
+        });
+        templateResolver.addPrompt({
+            flagName: 'templateIds',
+            type: 'checkbox',
+            message: `Select ${typeName} templates to delete:`,
+            choices: () => templates.map(t => ({
+                name: t.name,
+                value: t.id,
+                command: `prlt template delete --type ${templateType} --templateIds "${t.id}" --json`,
+            })),
+        });
+        const resolvedTemplates = await templateResolver.resolve();
+        const selected = resolvedTemplates.templateIds || [];
         if (selected.length === 0) {
             this.log(styles.muted('\nNo templates selected.'));
             return;
         }
-        // Confirm deletion
+        // Confirm deletion (using agentPrompt for confirmation)
         if (!flags.force) {
-            const { confirm } = await inquirer.prompt([{
+            const { confirm } = await this.prompt([{
                     type: 'list',
                     name: 'confirm',
                     message: `Delete ${selected.length} ${typeName} template(s)?`,
                     choices: [
-                        { name: 'No', value: false },
-                        { name: 'Yes', value: true },
+                        { name: 'No', value: false, command: '' },
+                        { name: 'Yes', value: true, command: `prlt template delete --type ${templateType} --templateIds "${selected.join(',')}" --force --json` },
                     ],
-                    default: 0,
-                }]);
+                }], jsonMode ? { flags, commandName: 'template delete' } : null);
             if (!confirm) {
                 this.log(styles.muted('Cancelled.'));
                 return;

package/dist/commands/template/index.d.ts

@@ -4,6 +4,7 @@ export default class Template extends Command {
     static aliases: string[];
     static examples: string[];
     static flags: {
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/template/index.js

@@ -1,7 +1,7 @@
-import { Command, Flags } from '@oclif/core';
-import inquirer from 'inquirer';
+import { Command } from '@oclif/core';
 import { styles } from '../../lib/styles.js';
-import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { FlagResolver, shouldOutputJson } from '../../lib/flags/index.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
 export default class Template extends Command {
     static description = 'Manage templates (ticket and phase)';
     static aliases = ['templates'];
@@ -13,43 +13,36 @@ export default class Template extends Command {
         '<%= config.bin %> <%= command.id %> phase',
     ];
     static flags = {
-        json: Flags.boolean({
-            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
-            default: false,
-        }),
+        ...machineOutputFlags,
     };
     async run() {
         const { flags } = await this.parse(Template);
-        // Check if JSON output mode is active
         const jsonMode = shouldOutputJson(flags);
-        // Define choices once, use for both JSON and interactive modes
-        const menuChoices = [
-            { name: 'List all templates', value: 'list' },
-            new inquirer.Separator(),
-            { name: 'Ticket templates (ticket presets)', value: 'ticket' },
-            { name: 'Phase templates (project phases)', value: 'phase' },
-        ];
-        const message = 'What would you like to do?';
-        // In JSON mode, output menu prompt (without separators)
-        if (jsonMode) {
-            const jsonChoices = [
-                { name: 'List all templates', value: 'list' },
-                { name: 'Ticket templates (ticket presets)', value: 'ticket' },
-                { name: 'Phase templates (project phases)', value: 'phase' },
-            ];
-            outputPromptAsJson(buildPromptConfig('list', 'action', message, jsonChoices), createMetadata('template', flags));
-            return;
-        }
+        // Create resolver for action selection
+        const resolver = new FlagResolver({
+            commandName: 'template',
+            baseCommand: 'prlt template',
+            jsonMode,
+            flags: {},
+        });
+        resolver.addPrompt({
+            flagName: 'action',
+            type: 'list',
+            message: 'What would you like to do?',
+            choices: () => [
+                { name: 'List all templates', value: 'list', command: 'prlt template list --json' },
+                { name: 'Ticket templates (ticket presets)', value: 'ticket', command: 'prlt template ticket --json' },
+                { name: 'Phase templates (project phases)', value: 'phase', command: 'prlt template phase --json' },
+            ],
+        });
+        // In JSON mode, this outputs the prompt and exits
+        // In interactive mode, this prompts and returns the value
+        const resolved = await resolver.resolve();
+        // Only reached in interactive mode
         this.log('');
         this.log(styles.header('Templates'));
         this.log('');
-        const { action } = await inquirer.prompt([{
-                type: 'list',
-                name: 'action',
-                message,
-                choices: menuChoices,
-            }]);
-        switch (action) {
+        switch (resolved.action) {
             case 'list':
                 await this.config.runCommand('template:list', []);
                 break;