@proletariat/cli 0.3.22 → 0.3.24

package/dist/commands/template/apply.js

@@ -0,0 +1,262 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
+import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildFormPromptConfig, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class TemplateApply extends PMOCommand {
+    static description = 'Apply a template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --type ticket bug-report',
+        '<%= config.bin %> <%= command.id %> --type ticket bug-report --title "Login fails"',
+        '<%= config.bin %> <%= command.id %> --type phase agile',
+        '<%= config.bin %> <%= command.id %> --type phase default --force',
+    ];
+    static args = {
+        template: Args.string({
+            description: 'Template ID to apply',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Template type',
+            options: ['ticket', 'phase'],
+        }),
+        // Ticket-specific flags
+        title: Flags.string({
+            description: 'Ticket title (ticket only)',
+        }),
+        column: Flags.string({
+            char: 'c',
+            description: 'Column to place ticket (ticket only)',
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'Priority override (ticket only)',
+            options: [...PRIORITIES],
+        }),
+        category: Flags.string({
+            description: 'Category override (ticket only)',
+        }),
+        assignee: Flags.string({
+            char: 'a',
+            description: 'Assignee (ticket only)',
+        }),
+        owner: Flags.string({
+            char: 'o',
+            description: 'Owner (ticket only)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Description override (ticket only)',
+        }),
+        epic: Flags.string({
+            char: 'e',
+            description: 'Link to epic (ticket only)',
+        }),
+        'no-subtasks': Flags.boolean({
+            description: 'Skip creating subtasks (ticket only)',
+            default: false,
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode (ticket only)',
+            default: false,
+        }),
+        // Phase-specific flags
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation (phase only)',
+            default: false,
+        }),
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output as JSON for AI agents/scripts',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TemplateApply);
+        const jsonMode = shouldOutputJson(flags);
+        // Determine template type
+        let templateType = flags.type;
+        if (!templateType) {
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'type', 'What type of template?', [
+                    { name: 'Ticket template', value: 'ticket' },
+                    { name: 'Phase template', value: 'phase' },
+                ]), createMetadata('template apply', flags));
+                return;
+            }
+            const { selectedType } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedType',
+                    message: 'What type of template?',
+                    choices: [
+                        { name: 'Ticket template', value: 'ticket' },
+                        { name: 'Phase template', value: 'phase' },
+                    ],
+                }]);
+            templateType = selectedType;
+        }
+        if (templateType === 'ticket') {
+            await this.applyTicketTemplate(args.template, flags, jsonMode);
+        }
+        else {
+            await this.applyPhaseTemplate(args.template, flags, jsonMode);
+        }
+    }
+    async applyTicketTemplate(templateId, flags, jsonMode) {
+        const projectId = await this.requireProject();
+        const board = await this.storage.getBoard(projectId);
+        const columns = board.columns.map(col => col.name);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('template apply', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get template
+        if (!templateId) {
+            const templates = await this.storage.listTicketTemplates();
+            if (templates.length === 0) {
+                return handleError('NO_TEMPLATES', 'No ticket templates. Create with: prlt template create --type ticket');
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select template:',
+                    choices: templates.map(t => ({ name: `${t.name}${t.description ? ` - ${t.description}` : ''}`, value: t.id })),
+                }]);
+            templateId = selected;
+        }
+        const template = await this.storage.getTicketTemplate(templateId);
+        if (!template) {
+            return handleError('TEMPLATE_NOT_FOUND', `Template not found: ${templateId}`);
+        }
+        // Determine ticket data
+        let title = flags.title || template.titlePattern || '';
+        let column = flags.column || columns[0];
+        let priority = flags.priority || template.defaultPriority;
+        let category = flags.category || template.defaultCategory;
+        let assignee = flags.assignee || template.defaultAssignee;
+        let owner = flags.owner || template.defaultOwner;
+        let description = flags.description || template.descriptionTemplate;
+        const labels = template.defaultLabels;
+        // Interactive mode
+        if (flags.interactive || !title) {
+            const fields = [
+                { type: 'input', name: 'title', message: 'Title:', default: title || undefined },
+                { type: 'list', name: 'column', message: 'Column:', choices: columns.map(c => ({ name: c, value: c })), default: column },
+                { type: 'list', name: 'priority', message: 'Priority:', choices: [{ name: 'None', value: '' }, ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p }))], default: priority },
+            ];
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('template apply', flags));
+                return;
+            }
+            const answers = await inquirer.prompt(fields.map(f => ({
+                ...f,
+                validate: f.name === 'title' ? ((i) => i.length > 0 || 'Required') : undefined,
+            })));
+            title = answers.title;
+            column = answers.column;
+            priority = answers.priority || undefined;
+        }
+        // Validate epic if provided
+        if (flags.epic) {
+            const epic = await this.storage.getEpic(flags.epic);
+            if (!epic)
+                this.error(`Epic not found: ${flags.epic}`);
+        }
+        // Create ticket
+        const ticket = await this.storage.createTicket(projectId, {
+            title,
+            statusName: column,
+            priority,
+            category,
+            assignee,
+            owner,
+            labels,
+            description,
+            epicId: flags.epic,
+        });
+        // Add subtasks
+        if (!flags['no-subtasks'] && template.suggestedSubtasks.length > 0) {
+            for (const subtask of template.suggestedSubtasks) {
+                await this.storage.addSubtask(ticket.id, subtask.title);
+            }
+        }
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\nCreated ticket ${styles.emphasis(ticket.id)} from template "${template.name}"`));
+        this.log(styles.muted(`  Title: ${ticket.title}`));
+        this.log(styles.muted(`  Status: ${ticket.statusName}`));
+        if (priority)
+            this.log(styles.muted(`  Priority: ${priority}`));
+        if (template.suggestedSubtasks.length > 0 && !flags['no-subtasks']) {
+            this.log(styles.muted(`  Subtasks: ${template.suggestedSubtasks.length} created`));
+        }
+    }
+    async applyPhaseTemplate(templateId, flags, jsonMode) {
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('template apply', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get template
+        if (!templateId) {
+            const templates = await this.storage.listPhaseTemplates();
+            if (templates.length === 0) {
+                return handleError('NO_TEMPLATES', 'No phase templates. Create with: prlt template create --type phase');
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select phase template:',
+                    choices: templates.map(t => ({ name: `${t.name}${t.description ? ` - ${t.description}` : ''}`, value: t.id })),
+                }]);
+            templateId = selected;
+        }
+        const template = await this.storage.getPhaseTemplate(templateId);
+        if (!template) {
+            return handleError('TEMPLATE_NOT_FOUND', `Template not found: ${templateId}`);
+        }
+        // Check existing phases
+        const existingPhases = await this.storage.listPhases();
+        if (existingPhases.length > 0 && !flags.force) {
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', `Replace ${existingPhases.length} existing phase(s)?`, [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ]), createMetadata('template apply', flags));
+                return;
+            }
+            this.log(styles.warning(`\nThis will REPLACE ${existingPhases.length} existing phase(s).`));
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: `Apply template "${template.name}"?`,
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes', value: true },
+                    ],
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled'));
+                return;
+            }
+        }
+        const phases = await this.storage.applyPhaseTemplate(templateId);
+        this.log(styles.success(`\nApplied phase template "${styles.emphasis(template.name)}"`));
+        this.log(styles.muted(`Created ${phases.length} phases:`));
+        for (const phase of phases) {
+            this.log(styles.muted(`  • ${phase.name} [${phase.category}]`));
+        }
+    }
+}

package/dist/commands/{ticket/template → template}/create.d.ts

@@ -1,11 +1,12 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
-export default class TicketTemplateCreate extends PMOCommand {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TemplateCreate extends PMOCommand {
     static description: string;
     static examples: string[];
     static args: {
         name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        type: 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>;
         'title-pattern': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'description-template': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -21,8 +22,6 @@ export default class TicketTemplateCreate extends PMOCommand {
         promptIfMultiple: boolean;
     };
     execute(): Promise<void>;
-    /**
-     * Check if any non-default flags were provided (indicating non-interactive intent)
-     */
-    private hasNonDefaultFlags;
+    private createTicketTemplate;
+    private createPhaseTemplate;
 }

package/dist/commands/template/create.js

@@ -0,0 +1,238 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { PRIORITIES, PRIORITY_LABELS, TICKET_CATEGORIES } from '../../lib/pmo/types.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputSuccessAsJson, outputPromptAsJson, outputErrorAsJson, buildFormPromptConfig, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class TemplateCreate extends PMOCommand {
+    static description = 'Create a new template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --type ticket "Bug Report"',
+        '<%= config.bin %> <%= command.id %> --type ticket "Feature" -d "For new features"',
+        '<%= config.bin %> <%= command.id %> --type phase "My Phases"',
+        '<%= config.bin %> <%= command.id %> --type phase "Enterprise" --description "Enterprise lifecycle"',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Template name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Template type',
+            options: ['ticket', 'phase'],
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+        // Ticket-specific flags
+        'title-pattern': Flags.string({
+            description: 'Default title prefix/pattern (ticket only)',
+        }),
+        'description-template': Flags.string({
+            description: 'Default description template (ticket only)',
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'Default priority (ticket only)',
+            options: [...PRIORITIES],
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'Default category (ticket only)',
+            options: [...TICKET_CATEGORIES],
+        }),
+        subtask: Flags.string({
+            description: 'Add a suggested subtask (ticket only, can repeat)',
+            multiple: true,
+        }),
+        ac: Flags.string({
+            description: 'Add an acceptance criterion (ticket only, can repeat)',
+            multiple: true,
+        }),
+        label: Flags.string({
+            char: 'l',
+            description: 'Add a default label (ticket only, can repeat)',
+            multiple: true,
+        }),
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output as JSON for AI agents/scripts',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(TemplateCreate);
+        const jsonMode = shouldOutputJson(flags);
+        // Determine template type
+        let templateType = flags.type;
+        if (!templateType) {
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'type', 'What type of template?', [
+                    { name: 'Ticket template', value: 'ticket' },
+                    { name: 'Phase template', value: 'phase' },
+                ]), createMetadata('template create', flags));
+                return;
+            }
+            const { selectedType } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedType',
+                    message: 'What type of template?',
+                    choices: [
+                        { name: 'Ticket template', value: 'ticket' },
+                        { name: 'Phase template', value: 'phase' },
+                    ],
+                }]);
+            templateType = selectedType;
+        }
+        if (templateType === 'ticket') {
+            await this.createTicketTemplate(args.name, flags, jsonMode);
+        }
+        else {
+            await this.createPhaseTemplate(args.name, flags, jsonMode);
+        }
+    }
+    async createTicketTemplate(name, flags, jsonMode) {
+        // Check if we have required data
+        if (!name) {
+            if (jsonMode) {
+                const fields = [
+                    { type: 'input', name: 'name', message: 'Template name:' },
+                    { type: 'input', name: 'description', message: 'Description (optional):' },
+                    {
+                        type: 'list',
+                        name: 'priority',
+                        message: 'Default priority:',
+                        choices: [
+                            { name: 'None', value: '' },
+                            ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                        ],
+                    },
+                    {
+                        type: 'list',
+                        name: 'category',
+                        message: 'Default category:',
+                        choices: [
+                            { name: 'None', value: '' },
+                            ...TICKET_CATEGORIES.map(c => ({ name: c, value: c })),
+                        ],
+                    },
+                ];
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('template create', flags));
+                return;
+            }
+            const { templateName } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'templateName',
+                    message: 'Template name:',
+                    validate: (input) => input.trim() ? true : 'Name required',
+                }]);
+            name = templateName;
+        }
+        // Get optional values
+        let description = flags.description;
+        let titlePattern = flags['title-pattern'];
+        let priority = flags.priority;
+        let category = flags.category;
+        const subtasks = flags.subtask || [];
+        const acs = flags.ac || [];
+        const labels = flags.label || [];
+        let descriptionTemplate = flags['description-template'];
+        // Interactive prompts for missing optional values
+        if (!jsonMode && description === undefined) {
+            const { desc } = await inquirer.prompt([{
+                    type: 'input', name: 'desc', message: 'Description (optional):',
+                }]);
+            description = desc || undefined;
+        }
+        if (!jsonMode && priority === undefined) {
+            const { p } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'p',
+                    message: 'Default priority:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...PRIORITIES.map(pr => ({ name: PRIORITY_LABELS[pr], value: pr })),
+                    ],
+                }]);
+            priority = p || undefined;
+        }
+        if (!jsonMode && category === undefined) {
+            const { c } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'c',
+                    message: 'Default category:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...TICKET_CATEGORIES.map(cat => ({ name: cat, value: cat })),
+                    ],
+                }]);
+            category = c || undefined;
+        }
+        // Build description template with ACs
+        if (acs.length > 0 && !descriptionTemplate) {
+            descriptionTemplate = '## Description\n\n## Acceptance Criteria\n' +
+                acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+        }
+        // Create the template
+        const template = await this.storage.createTicketTemplate({
+            name: name,
+            description,
+            titlePattern,
+            defaultPriority: priority,
+            defaultCategory: category,
+            descriptionTemplate,
+            suggestedSubtasks: subtasks.map(title => ({ title })),
+            defaultLabels: labels,
+        });
+        if (jsonMode) {
+            outputSuccessAsJson({ template }, createMetadata('template create', flags));
+            return;
+        }
+        this.log(styles.success(`\nCreated ticket template "${styles.emphasis(template.name)}"`));
+        this.log(styles.muted(`  ID: ${template.id}`));
+        this.log(styles.muted(`\nApply with: prlt template apply --type ticket ${template.id}`));
+    }
+    async createPhaseTemplate(name, flags, jsonMode) {
+        if (!name) {
+            if (jsonMode) {
+                outputErrorAsJson('NAME_REQUIRED', 'Name required: prlt template create --type phase "Name"', createMetadata('template create', flags));
+                return;
+            }
+            const { templateName } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'templateName',
+                    message: 'Template name:',
+                    validate: (input) => input.trim() ? true : 'Name required',
+                }]);
+            name = templateName;
+        }
+        let description = flags.description;
+        if (!jsonMode && description === undefined) {
+            const { desc } = await inquirer.prompt([{
+                    type: 'input', name: 'desc', message: 'Description (optional):',
+                }]);
+            description = desc || undefined;
+        }
+        const template = await this.storage.savePhaseTemplate(name, description);
+        if (jsonMode) {
+            outputSuccessAsJson({
+                id: template.id,
+                name: template.name,
+                phasesCount: template.phases.length,
+            }, createMetadata('template create', flags));
+            return;
+        }
+        this.log(styles.success(`\nCreated phase template "${styles.emphasis(template.name)}" (${template.id})`));
+        this.log(styles.muted(`Saved ${template.phases.length} phases`));
+        this.log(styles.muted(`\nApply with: prlt template apply --type phase ${template.id}`));
+    }
+}

package/dist/commands/template/index.js

@@ -1,56 +1,68 @@
-import { Command } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
 import { styles } from '../../lib/styles.js';
-import { FlagResolver, shouldOutputJson } from '../../lib/flags/index.js';
-import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, buildPromptConfig, createMetadata } from '../../lib/prompt-json.js';
 export default class Template extends Command {
     static description = 'Manage templates (ticket and phase)';
     static aliases = ['templates'];
     static examples = [
-        '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> list',
         '<%= config.bin %> <%= command.id %> list --type ticket',
-        '<%= config.bin %> <%= command.id %> ticket',
-        '<%= config.bin %> <%= command.id %> phase',
+        '<%= config.bin %> <%= command.id %> create --type ticket "Bug Report"',
+        '<%= config.bin %> <%= command.id %> apply --type phase agile',
     ];
     static flags = {
-        ...machineOutputFlags,
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output as JSON for AI agents/scripts',
+            default: false,
+        }),
     };
     async run() {
         const { flags } = await this.parse(Template);
         const jsonMode = shouldOutputJson(flags);
-        // 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('');
-        switch (resolved.action) {
+        const menuChoices = [
+            { name: 'List templates', value: 'list', command: 'prlt template list --json' },
+            { name: 'Create template', value: 'create', command: 'prlt template create --json' },
+            { name: 'Apply template', value: 'apply', command: 'prlt template apply --json' },
+            { name: 'Save ticket as template', value: 'save', command: 'prlt template save --json' },
+            { name: 'Update phase template', value: 'update', command: 'prlt template update --json' },
+            { name: 'Delete template', value: 'delete', command: 'prlt template delete --json' },
+            { name: 'Cancel', value: 'cancel', command: '' },
+        ];
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', 'What would you like to do?', menuChoices), createMetadata('template', flags));
+            return;
+        }
+        this.log(`\n${styles.emphasis('Templates')}`);
+        this.log(styles.muted('Manage ticket and phase templates\n'));
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: menuChoices.map(c => ({ name: c.name, value: c.value })),
+            }]);
+        if (action === 'cancel')
+            return;
+        switch (action) {
             case 'list':
                 await this.config.runCommand('template:list', []);
                 break;
-            case 'ticket':
-                await this.config.runCommand('template:ticket', []);
+            case 'create':
+                await this.config.runCommand('template:create', []);
+                break;
+            case 'apply':
+                await this.config.runCommand('template:apply', []);
+                break;
+            case 'save':
+                await this.config.runCommand('template:save', []);
+                break;
+            case 'update':
+                await this.config.runCommand('template:update', []);
                 break;
-            case 'phase':
-                await this.config.runCommand('template:phase', []);
+            case 'delete':
+                await this.config.runCommand('template:delete', []);
                 break;
         }
     }

package/dist/commands/{ticket/template → template}/save.d.ts

@@ -1,5 +1,5 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
-export default class TicketTemplateSave extends PMOCommand {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TemplateSave extends PMOCommand {
     static description: string;
     static examples: string[];
     static args: {