@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/ticket/template/create.js

@@ -0,0 +1,210 @@
+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';
+export default class TicketTemplateCreate extends PMOCommand {
+    static description = 'Create a new ticket template from scratch';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "Bug Report"',
+        '<%= config.bin %> <%= command.id %> "Feature Request" -d "Template for new features"',
+        '<%= config.bin %> <%= command.id %> "Task" --title-pattern "[TASK] " --priority P2',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Template name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+        'title-pattern': Flags.string({
+            description: 'Default title prefix/pattern (e.g., "[BUG] ")',
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'Default priority',
+            options: [...PRIORITIES],
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'Default category',
+            options: [...TICKET_CATEGORIES],
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(TicketTemplateCreate);
+        // Get template name
+        let name = args.name;
+        if (!name) {
+            const { templateName } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'templateName',
+                    message: 'Template name:',
+                    validate: (input) => input.length > 0 || 'Name is required',
+                }]);
+            name = templateName;
+        }
+        // Get description if not provided
+        let description = flags.description;
+        if (description === undefined) {
+            const { templateDescription } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'templateDescription',
+                    message: 'Description (optional):',
+                }]);
+            description = templateDescription || undefined;
+        }
+        // Get title pattern
+        let titlePattern = flags['title-pattern'];
+        if (titlePattern === undefined) {
+            const { pattern } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'pattern',
+                    message: 'Title prefix/pattern (optional, e.g., "[BUG] "):',
+                }]);
+            titlePattern = pattern || undefined;
+        }
+        // Get default priority
+        let priority = flags.priority;
+        if (priority === undefined) {
+            const { selectedPriority } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedPriority',
+                    message: 'Default priority:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                    ],
+                }]);
+            priority = selectedPriority || undefined;
+        }
+        // Get default category
+        let category = flags.category;
+        if (category === undefined) {
+            const { selectedCategory } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedCategory',
+                    message: 'Default category:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...TICKET_CATEGORIES.map(c => ({ name: c, value: c })),
+                    ],
+                }]);
+            category = selectedCategory || undefined;
+        }
+        // Ask about description template
+        const { wantDescriptionTemplate } = await inquirer.prompt([{
+                type: 'list',
+                name: 'wantDescriptionTemplate',
+                message: 'Add a description template?',
+                choices: [
+                    { name: 'No', value: false },
+                    { name: 'Yes', value: true },
+                ],
+            }]);
+        let descriptionTemplate;
+        if (wantDescriptionTemplate) {
+            const { template } = await inquirer.prompt([{
+                    type: 'editor',
+                    name: 'template',
+                    message: 'Description template (opens editor):',
+                    default: `## Summary\n\n## Details\n\n## Acceptance Criteria\n- [ ] \n`,
+                }]);
+            descriptionTemplate = template || undefined;
+        }
+        // Ask about default subtasks
+        const subtasks = [];
+        const { wantSubtasks } = await inquirer.prompt([{
+                type: 'list',
+                name: 'wantSubtasks',
+                message: 'Add default subtasks?',
+                choices: [
+                    { name: 'No', value: false },
+                    { name: 'Yes', value: true },
+                ],
+            }]);
+        if (wantSubtasks) {
+            let addMore = true;
+            while (addMore) {
+                const { subtaskTitle } = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'subtaskTitle',
+                        message: 'Subtask title:',
+                        validate: (input) => input.length > 0 || 'Title is required',
+                    }]);
+                subtasks.push(subtaskTitle);
+                const { another } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'another',
+                        message: 'Add another subtask?',
+                        choices: [
+                            { name: 'No', value: false },
+                            { name: 'Yes', value: true },
+                        ],
+                    }]);
+                addMore = another;
+            }
+        }
+        // Show preview
+        this.log(`\n${styles.emphasis('Template Preview:')}`);
+        this.log(styles.muted(`  Name: ${name}`));
+        if (description) {
+            this.log(styles.muted(`  Description: ${description}`));
+        }
+        if (titlePattern) {
+            this.log(styles.muted(`  Title pattern: ${titlePattern}`));
+        }
+        if (priority) {
+            this.log(styles.muted(`  Default priority: ${PRIORITY_LABELS[priority] || priority}`));
+        }
+        if (category) {
+            this.log(styles.muted(`  Default category: ${category}`));
+        }
+        if (descriptionTemplate) {
+            this.log(styles.muted(`  Description template: (custom)`));
+        }
+        if (subtasks.length > 0) {
+            this.log(styles.muted(`  Default subtasks:`));
+            for (const subtask of subtasks) {
+                this.log(styles.muted(`    - ${subtask}`));
+            }
+        }
+        // Confirm creation
+        const { confirm } = await inquirer.prompt([{
+                type: 'list',
+                name: 'confirm',
+                message: 'Create this template?',
+                choices: [
+                    { name: 'Yes', value: true },
+                    { name: 'No', value: false },
+                ],
+            }]);
+        if (!confirm) {
+            this.log(styles.muted('Cancelled.'));
+            return;
+        }
+        // Create the template
+        const template = await this.storage.createTicketTemplate({
+            name: name,
+            description,
+            titlePattern,
+            defaultPriority: priority,
+            defaultCategory: category,
+            descriptionTemplate,
+            suggestedSubtasks: subtasks.map(title => ({ title })),
+            defaultLabels: [],
+        });
+        this.log(styles.success(`\nCreated template "${styles.emphasis(template.name)}"`));
+        this.log(styles.muted(`  ID: ${template.id}`));
+        this.log('');
+        this.log(styles.muted(`Create ticket from template: prlt ticket template apply ${template.id}`));
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class TicketTemplateDelete extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/ticket/template/delete.js

@@ -0,0 +1,92 @@
+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, outputErrorAsJson, createMetadata, } from '../../../lib/prompt-json.js';
+export default class TicketTemplateDelete extends PMOCommand {
+    static description = 'Delete a ticket template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-template',
+        '<%= config.bin %> <%= command.id %> my-template --force',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Template ID to delete',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(TicketTemplateDelete);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('ticket template delete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get template - prompt for selection if not provided
+        let templateId = args.id;
+        if (!templateId) {
+            const templates = await this.storage.listTicketTemplates();
+            const deletableTemplates = templates.filter(t => !t.isBuiltin);
+            if (deletableTemplates.length === 0) {
+                return handleError('NO_TEMPLATES', `No deletable ticket templates found (built-in templates cannot be deleted).`);
+            }
+            const { selectedTemplate } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedTemplate',
+                    message: 'Select a template to delete:',
+                    choices: deletableTemplates.map(t => ({
+                        name: `${t.name}${t.description ? ` - ${t.description}` : ''}`,
+                        value: t.id,
+                    })),
+                }]);
+            templateId = selectedTemplate;
+        }
+        const template = await this.storage.getTicketTemplate(templateId);
+        if (!template) {
+            return handleError('TEMPLATE_NOT_FOUND', `Template "${templateId}" not found.\nRun 'prlt ticket template list' to see available templates.`);
+        }
+        if (template.isBuiltin) {
+            return handleError('CANNOT_DELETE_BUILTIN', 'Cannot delete built-in templates.');
+        }
+        if (!flags.force) {
+            const confirmChoices = [
+                { id: 'no', name: 'No, cancel' },
+                { id: 'yes', name: `Yes, delete "${template.name}"` },
+            ];
+            const confirm = await this.selectFromList({
+                message: `Delete template "${template.name}"?`,
+                items: confirmChoices,
+                getName: (c) => c.name,
+                getValue: (c) => c.id,
+                getCommand: (c) => c.id === 'yes' ? `prlt ticket template delete ${templateId} --force` : '',
+                jsonMode: jsonMode ? { flags, commandName: 'ticket template delete' } : null,
+            });
+            if (confirm !== 'yes') {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        await this.storage.deleteTicketTemplate(templateId);
+        this.log(styles.success(`\nDeleted template "${template.name}"`));
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class TicketTemplateIndex extends PMOCommand {
+    static description: string;
+    static aliases: string[];
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private selectTemplate;
+}

package/dist/commands/ticket/template/index.js

@@ -0,0 +1,118 @@
+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, } from '../../../lib/prompt-json.js';
+export default class TicketTemplateIndex extends PMOCommand {
+    static description = 'Interactive menu for ticket template operations';
+    static aliases = ['ticket:templates'];
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(TicketTemplateIndex);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        const menuChoices = [
+            { id: 'list', name: 'List available templates', command: 'prlt ticket template list --format json' },
+            { id: 'create', name: 'Create new template', command: 'prlt ticket template create --json' },
+            { id: 'apply', name: 'Create ticket from template', command: 'prlt ticket template apply --json' },
+            { id: 'save', name: 'Save ticket as template', command: 'prlt ticket template save --json' },
+            { id: 'delete', name: 'Delete template', command: 'prlt ticket template delete --json' },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'Ticket Templates - What would you like to do?';
+        const action = await this.selectFromList({
+            message: '📋 ' + message,
+            items: menuChoices,
+            getName: (c) => c.name,
+            getValue: (c) => c.id,
+            getCommand: (c) => c.command,
+            jsonMode: jsonMode ? { flags, commandName: 'ticket template' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            return;
+        }
+        // Run the selected subcommand
+        switch (action) {
+            case 'list':
+                await this.config.runCommand('ticket:template:list', []);
+                break;
+            case 'create':
+                await this.config.runCommand('ticket:template:create', []);
+                break;
+            case 'apply': {
+                const templateId = await this.selectTemplate('Select template to use:');
+                if (templateId) {
+                    await this.config.runCommand('ticket:template:apply', [templateId, '--interactive']);
+                }
+                break;
+            }
+            case 'save': {
+                // Prompt for ticket ID and template name
+                const saveAnswers = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'ticketId',
+                        message: 'Ticket ID to save as template:',
+                        validate: (input) => input.length > 0 || 'Ticket ID is required',
+                    },
+                    {
+                        type: 'input',
+                        name: 'name',
+                        message: 'Template name:',
+                        validate: (input) => input.length > 0 || 'Name is required',
+                    },
+                ]);
+                await this.config.runCommand('ticket:template:save', [saveAnswers.ticketId, saveAnswers.name]);
+                break;
+            }
+            case 'delete': {
+                const customTemplates = (await this.storage.listTicketTemplates()).filter(t => !t.isBuiltin);
+                if (customTemplates.length === 0) {
+                    this.log(styles.muted('No custom templates to delete. Built-in templates cannot be deleted.'));
+                    return;
+                }
+                const templateId = await this.selectTemplate('Select template to delete:', true);
+                if (templateId) {
+                    await this.config.runCommand('ticket:template:delete', [templateId]);
+                }
+                break;
+            }
+        }
+    }
+    async selectTemplate(message, customOnly = false) {
+        let templates = await this.storage.listTicketTemplates();
+        if (customOnly) {
+            templates = templates.filter(t => !t.isBuiltin);
+        }
+        if (templates.length === 0) {
+            this.log(styles.muted('No templates found.'));
+            return null;
+        }
+        const templateChoices = templates.map(t => ({
+            id: t.id,
+            name: `${t.name} (${t.id})${t.isBuiltin ? '' : ' [custom]'}`,
+        }));
+        const selected = await this.selectFromList({
+            message,
+            items: templateChoices,
+            getName: (t) => t.name,
+            getValue: (t) => t.id,
+            getCommand: (t) => `prlt ticket template apply ${t.id} --json`,
+            allowCancel: true,
+        });
+        return selected;
+    }
+}

package/dist/commands/ticket/template/list.d.ts

@@ -0,0 +1,16 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class TicketTemplateList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        builtin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        custom: 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>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private printTemplate;
+}

package/dist/commands/ticket/template/list.js

@@ -0,0 +1,110 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+export default class TicketTemplateList extends PMOCommand {
+    static description = 'List available ticket templates';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --builtin  # Only built-in templates',
+        '<%= config.bin %> <%= command.id %> --custom   # Only custom templates',
+        '<%= config.bin %> <%= command.id %> --json     # Output as JSON',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        builtin: Flags.boolean({
+            description: 'Show only built-in templates',
+            exclusive: ['custom'],
+        }),
+        custom: Flags.boolean({
+            description: 'Show only custom templates',
+            exclusive: ['builtin'],
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(TicketTemplateList);
+        let filter;
+        if (flags.builtin)
+            filter = { isBuiltin: true };
+        if (flags.custom)
+            filter = { isBuiltin: false };
+        const templates = await this.storage.listTicketTemplates(filter);
+        if (flags.json) {
+            this.log(JSON.stringify(templates, null, 2));
+            return;
+        }
+        if (templates.length === 0) {
+            this.log(styles.muted('\nNo ticket templates found.'));
+            this.log(styles.muted('Create one: prlt ticket template save <ticket-id> "Template Name"'));
+            return;
+        }
+        this.log(`\n📋 ${styles.emphasis('Ticket Templates')}`);
+        this.log('═'.repeat(60));
+        // Group by builtin vs custom
+        const builtinTemplates = templates.filter(t => t.isBuiltin);
+        const customTemplates = templates.filter(t => !t.isBuiltin);
+        if (builtinTemplates.length > 0 && !flags.custom) {
+            this.log(`\n${styles.emphasis('Built-in Templates')}`);
+            this.log('─'.repeat(40));
+            for (const template of builtinTemplates) {
+                this.printTemplate(template);
+            }
+        }
+        if (customTemplates.length > 0 && !flags.builtin) {
+            this.log(`\n${styles.emphasis('Custom Templates')}`);
+            this.log('─'.repeat(40));
+            for (const template of customTemplates) {
+                this.printTemplate(template);
+            }
+        }
+        this.log('');
+        this.log(styles.muted('Create ticket from template: prlt ticket template apply <template-id>'));
+        this.log('');
+    }
+    printTemplate(template) {
+        this.log(`\n  ${styles.emphasis(template.name)} ${styles.muted(`(${template.id})`)}`);
+        if (template.description) {
+            this.log(`    ${styles.muted(template.description)}`);
+        }
+        // Show template details - first line
+        const details = [];
+        if (template.defaultPriority) {
+            details.push(`Priority: ${template.defaultPriority}`);
+        }
+        if (template.defaultCategory) {
+            details.push(`Category: ${template.defaultCategory}`);
+        }
+        if (template.suggestedSubtasks.length > 0) {
+            details.push(`Subtasks: ${template.suggestedSubtasks.length}`);
+        }
+        if (details.length > 0) {
+            this.log(`    ${styles.muted(details.join(' | '))}`);
+        }
+        // Show additional details - second line
+        const details2 = [];
+        if (template.defaultStatusId) {
+            details2.push(`Status: ${template.defaultStatusId}`);
+        }
+        if (template.defaultAssignee) {
+            details2.push(`Assignee: ${template.defaultAssignee}`);
+        }
+        if (template.defaultOwner) {
+            details2.push(`Owner: ${template.defaultOwner}`);
+        }
+        if (template.defaultLabels && template.defaultLabels.length > 0) {
+            details2.push(`Labels: ${template.defaultLabels.join(', ')}`);
+        }
+        if (details2.length > 0) {
+            this.log(`    ${styles.muted(details2.join(' | '))}`);
+        }
+        if (template.titlePattern) {
+            this.log(`    ${styles.muted(`Title: "${template.titlePattern}"`)}`);
+        }
+    }
+}

package/dist/commands/ticket/template/save.d.ts

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class TicketTemplateSave extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticket: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+}