@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/ticket/complete.js

@@ -0,0 +1,170 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { autoExportToBoard, 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 TicketComplete extends PMOCommand {
+    static description = 'Mark ticket(s) as complete (move to Done column)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> TICK-001',
+        '<%= config.bin %> <%= command.id %> --bulk',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        bulk: Flags.boolean({
+            char: 'b',
+            description: 'Enable bulk mode to complete multiple tickets',
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt (bulk mode only)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketComplete);
+        const projectId = flags.project;
+        // 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 complete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get all incomplete tickets
+        const allTickets = await this.storage.listTickets(projectId);
+        const incompleteTickets = allTickets.filter(t => t.statusName && !t.statusName.toLowerCase().includes('done'));
+        if (incompleteTickets.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_INCOMPLETE_TICKETS', 'No incomplete tickets found. All tickets are done!', createMetadata('ticket complete', flags));
+                return;
+            }
+            this.log(styles.info('No incomplete tickets found. All tickets are done!'));
+            return;
+        }
+        // Get board for columns (use the first incomplete ticket's project)
+        const board = await this.storage.getBoard(incompleteTickets[0].projectId);
+        // Find the "Done" column (case-insensitive)
+        const doneColumn = board.columns.find(col => col.name.toLowerCase().includes('done'));
+        if (!doneColumn) {
+            return handleError('NO_DONE_COLUMN', 'No "Done" column found in board configuration.');
+        }
+        // Bulk mode
+        if (flags.bulk) {
+            await this.executeBulk(incompleteTickets, doneColumn.name, flags.force);
+            return;
+        }
+        // Single ticket mode
+        let ticketId = args.ticketId;
+        if (!ticketId) {
+            const selected = await this.selectFromList({
+                message: 'Select ticket to mark complete:',
+                items: incompleteTickets,
+                getName: (t) => `${t.id} - ${t.title} (${t.statusName})`,
+                getValue: (t) => t.id,
+                getCommand: (t) => `prlt ticket complete ${t.id} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'ticket complete' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            ticketId = selected;
+        }
+        // Get ticket
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            this.error(`Ticket "${ticketId}" not found.`);
+        }
+        // Move to Done column
+        await this.storage.moveTicket(ticket.projectId, ticketId, doneColumn.name);
+        // Auto-export to board.md if configured
+        await autoExportToBoard(this.pmoPath, this.storage);
+        this.log(styles.success(`✅ Completed ${ticketId}`));
+        this.log(styles.muted(`   Title: ${ticket.title}`));
+        this.log(styles.muted(`   Moved to: ${doneColumn.name}`));
+    }
+    async executeBulk(incompleteTickets, doneColumnName, force) {
+        this.log(styles.emphasis('✅ Complete Multiple Tickets\n'));
+        // Select tickets to complete
+        const { selectedTickets } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedTickets',
+                message: 'Select tickets to mark as COMPLETE:',
+                choices: incompleteTickets.map(t => ({
+                    name: `${t.id} - ${t.title} (${t.statusName})`,
+                    value: t.id,
+                })),
+            }]);
+        if (selectedTickets.length === 0) {
+            this.log(styles.muted('No tickets selected.'));
+            return;
+        }
+        // Confirmation
+        if (!force) {
+            this.log(styles.primary('\nWill mark as complete:'));
+            for (const ticketId of selectedTickets) {
+                const ticket = incompleteTickets.find(t => t.id === ticketId);
+                this.log(styles.primary(`  • ${ticketId}: ${ticket?.title}`));
+            }
+            this.log(styles.primary(`  → Move to: ${doneColumnName}\n`));
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: 'Continue?',
+                    choices: [
+                        { name: 'No, cancel', value: false },
+                        { name: 'Yes, complete tickets', value: true }
+                    ],
+                    default: 1
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Operation cancelled.'));
+                return;
+            }
+        }
+        this.log('');
+        // Complete each ticket
+        let successCount = 0;
+        let failCount = 0;
+        for (const ticketId of selectedTickets) {
+            try {
+                const ticket = incompleteTickets.find(t => t.id === ticketId);
+                if (!ticket) {
+                    throw new Error('Ticket not found in incomplete tickets list');
+                }
+                await this.storage.moveTicket(ticket.projectId, ticketId, doneColumnName);
+                this.log(styles.success(`Completed ${ticketId}`));
+                successCount++;
+            }
+            catch (error) {
+                this.log(styles.error(`Failed to complete ${ticketId}: ${error instanceof Error ? error.message : String(error)}`));
+                failCount++;
+            }
+        }
+        // Auto-export to kanban.md
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        // Summary
+        this.log('');
+        if (successCount > 0) {
+            this.log(styles.success(`Completed ${successCount} ticket(s)`));
+        }
+        if (failCount > 0) {
+            this.log(styles.error(`Failed to complete ${failCount} ticket(s)`));
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TicketCreate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        title: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        column: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        priority: 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>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        epic: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        template: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        labels: 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>;
+    private promptTicketData;
+    private promptStructuredDescription;
+}

package/dist/commands/ticket/create.js

@@ -0,0 +1,390 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { updateEpicTicketsSection } from '../../lib/pmo/epic-files.js';
+import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class TicketCreate extends PMOCommand {
+    static description = 'Create a new ticket on the PMO board';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --title "Fix login bug" --column Backlog',
+        '<%= config.bin %> <%= command.id %> -t "Add feature" -c "In Progress" -p HIGH',
+        '<%= config.bin %> <%= command.id %> --project mobile-app -t "New feature"',
+        '<%= config.bin %> <%= command.id %> --epic EPIC-001 -t "Implement auth flow"',
+        '<%= config.bin %> <%= command.id %> --json  # Output column choices as JSON',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        title: Flags.string({
+            char: 't',
+            description: 'Ticket title',
+        }),
+        column: Flags.string({
+            char: 'c',
+            description: 'Column to place the ticket in',
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'Ticket priority',
+            options: [...PRIORITIES],
+        }),
+        category: Flags.string({
+            description: 'Ticket category (e.g., bug, feature, refactor)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Ticket description',
+        }),
+        id: Flags.string({
+            description: 'Custom ticket ID (auto-generated if not provided)',
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode',
+            default: false,
+        }),
+        epic: Flags.string({
+            char: 'e',
+            description: 'Link ticket to an epic (e.g., EPIC-001)',
+        }),
+        template: Flags.string({
+            char: 'T',
+            description: 'Create from a template (e.g., bug-report, feature-request)',
+        }),
+        labels: Flags.string({
+            char: 'l',
+            description: 'Labels (comma-separated)',
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(TicketCreate);
+        // Get project and board info (pass JSON mode config for AI agents)
+        const projectId = await this.requireProject({
+            jsonMode: {
+                flags,
+                commandName: 'ticket create',
+                baseCommand: 'prlt ticket create',
+            },
+        });
+        const board = await this.storage.getBoard(projectId);
+        const columns = board.columns.map(c => c.name);
+        const projectName = await this.getProjectName(projectId);
+        // 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 create', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // In JSON mode without required data, output column selection prompt
+        if (jsonMode && !flags.title && !flags.column) {
+            // Build base command with project if specified
+            const baseCmd = flags.project
+                ? `prlt ticket create -P ${flags.project}`
+                : 'prlt ticket create';
+            const columnChoices = columns.map(c => ({
+                name: c,
+                value: c,
+                command: `${baseCmd} --column "${c}" --json`,
+            }));
+            outputPromptAsJson(buildPromptConfig('list', 'column', 'Select column to place the ticket in:', columnChoices), createMetadata('ticket create', flags));
+            return;
+        }
+        // Validate epic if provided
+        if (flags.epic) {
+            const epic = await this.storage.getEpic(flags.epic);
+            if (!epic) {
+                return handleError('EPIC_NOT_FOUND', `Epic not found: ${flags.epic}. Use 'prlt epic list' to see available epics.`);
+            }
+        }
+        // Load template if specified
+        let template = null;
+        if (flags.template) {
+            template = await this.storage.getTicketTemplate(flags.template);
+            if (!template) {
+                this.error(`Template not found: ${flags.template}. Run 'prlt ticket template list' to see available templates.`);
+            }
+        }
+        // Parse labels from flag
+        const labelsFromFlag = flags.labels
+            ? flags.labels.split(',').map(l => l.trim()).filter(l => l)
+            : undefined;
+        // Get ticket data (interactive or from flags)
+        let ticketData;
+        // In JSON mode with column but no title, output required fields info
+        if (jsonMode && flags.column && !flags.title) {
+            const baseCmd = flags.project
+                ? `prlt ticket create -P ${flags.project} --column "${flags.column}"`
+                : `prlt ticket create --column "${flags.column}"`;
+            outputPromptAsJson({
+                type: 'input',
+                name: 'title',
+                message: 'Enter ticket title:',
+                context: {
+                    hint: `Provide title with: ${baseCmd} --title "Your title here"`,
+                    requiredFields: ['--title'],
+                    optionalFields: ['--priority', '--category', '--description', '--epic', '--labels'],
+                    example: `${baseCmd} --title "Fix login bug" --priority P1 --category bug`,
+                },
+            }, createMetadata('ticket create', flags));
+            return;
+        }
+        if (flags.interactive || !flags.title) {
+            ticketData = await this.promptTicketData(flags, this.storage, template, columns);
+        }
+        else {
+            if (!flags.title && !template?.titlePattern) {
+                this.error('Title is required. Use --title or -t flag, or use --interactive mode.');
+            }
+            ticketData = {
+                title: flags.title || template?.titlePattern || '',
+                statusName: flags.column || columns[0],
+                priority: flags.priority || template?.defaultPriority,
+                category: flags.category || template?.defaultCategory,
+                description: flags.description || template?.descriptionTemplate,
+                id: flags.id,
+                epicId: flags.epic,
+                labels: labelsFromFlag || template?.defaultLabels,
+            };
+        }
+        // Validate status/column
+        if (!columns.includes(ticketData.statusName)) {
+            this.error(`Invalid column "${ticketData.statusName}". Available columns: ${columns.join(', ')}`);
+        }
+        const ticket = await this.storage.createTicket(projectId, {
+            id: ticketData.id,
+            title: ticketData.title,
+            statusName: ticketData.statusName,
+            priority: ticketData.priority,
+            category: ticketData.category,
+            description: ticketData.description,
+            epicId: ticketData.epicId,
+            labels: ticketData.labels,
+        });
+        // Add subtasks from template if applicable
+        if (template && template.suggestedSubtasks.length > 0) {
+            for (const subtask of template.suggestedSubtasks) {
+                await this.storage.addSubtask(ticket.id, subtask.title);
+            }
+        }
+        // Auto-export to board.md after write
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        // If linked to an epic, update the epic's markdown file with ticket list
+        if (ticketData.epicId) {
+            const epic = await this.storage.getEpic(ticketData.epicId);
+            if (epic) {
+                const epicTickets = await this.storage.getTicketsForEpic(projectId, ticketData.epicId);
+                const ticketInfos = epicTickets.map(t => ({
+                    id: t.id,
+                    title: t.title,
+                    status: t.statusName || 'Unknown',
+                    priority: t.priority,
+                }));
+                updateEpicTicketsSection(this.pmoPath, ticketData.epicId, epic.status, ticketInfos, projectId);
+            }
+        }
+        this.log(styles.success(`\n✅ Created ticket ${styles.emphasis(ticket.id)} in project ${styles.emphasis(projectName)}`));
+        if (template) {
+            this.log(styles.muted(`   Template: ${template.name}`));
+        }
+        this.log(styles.muted(`   Title: ${ticket.title}`));
+        this.log(styles.muted(`   Status: ${ticket.statusName}`));
+        if (ticket.priority) {
+            this.log(styles.muted(`   Priority: ${ticket.priority}`));
+        }
+        if (ticket.category) {
+            this.log(styles.muted(`   Category: ${ticket.category}`));
+        }
+        if (ticketData.epicId) {
+            this.log(styles.muted(`   Epic: ${ticketData.epicId}`));
+        }
+        if (ticketData.labels && ticketData.labels.length > 0) {
+            this.log(styles.muted(`   Labels: ${ticketData.labels.join(', ')}`));
+        }
+        if (template && template.suggestedSubtasks.length > 0) {
+            this.log(styles.muted(`   Subtasks: ${template.suggestedSubtasks.length} created`));
+        }
+        this.log(styles.muted(`\n   View board: prlt board`));
+        this.log(styles.muted(`   List tickets: prlt ticket list`));
+    }
+    async promptTicketData(flags, storage, existingTemplate, columns) {
+        // If no template was specified via flag, offer to select one
+        let template = existingTemplate;
+        if (!template && !flags.template) {
+            const templates = await storage.listTicketTemplates();
+            if (templates.length > 0) {
+                const { selectedTemplate } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'selectedTemplate',
+                        message: 'Start from a template?',
+                        choices: [
+                            { name: 'No template (blank ticket)', value: '' },
+                            new inquirer.Separator('── Templates ──'),
+                            ...templates.map(t => ({
+                                name: `${t.name}${t.isBuiltin ? '' : ' [custom]'} - ${t.description || ''}`,
+                                value: t.id,
+                            })),
+                        ],
+                    },
+                ]);
+                if (selectedTemplate) {
+                    template = templates.find(t => t.id === selectedTemplate) || null;
+                }
+            }
+        }
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'title',
+                message: 'Ticket title:',
+                default: flags.title || template?.titlePattern,
+                validate: (input) => input.length > 0 || 'Title is required',
+            },
+            {
+                type: 'list',
+                name: 'column',
+                message: 'Column:',
+                choices: columns,
+                default: flags.column || columns[0],
+            },
+            {
+                type: 'list',
+                name: 'priority',
+                message: 'Priority:',
+                choices: [
+                    { name: 'None', value: undefined },
+                    ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                ],
+                default: flags.priority || template?.defaultPriority,
+            },
+            {
+                type: 'list',
+                name: 'categoryChoice',
+                message: 'Category:',
+                choices: [
+                    { name: 'Skip (none)', value: '' },
+                    new inquirer.Separator('── Conventional Commits ──'),
+                    { name: 'feature     - New feature or capability', value: 'feature' },
+                    { name: 'bug         - Bug fix', value: 'bug' },
+                    { name: 'refactor    - Code refactoring', value: 'refactor' },
+                    { name: 'docs        - Documentation', value: 'docs' },
+                    { name: 'test        - Test additions/fixes', value: 'test' },
+                    { name: 'chore       - Maintenance tasks', value: 'chore' },
+                    { name: 'performance - Performance improvements', value: 'performance' },
+                    { name: 'ci          - CI/CD changes', value: 'ci' },
+                    { name: 'build       - Build system changes', value: 'build' },
+                    new inquirer.Separator('── Extended Types ──'),
+                    { name: 'security    - Security fixes', value: 'security' },
+                    { name: 'database    - Database migrations', value: 'database' },
+                    { name: 'release     - Release preparation', value: 'release' },
+                    new inquirer.Separator('── 5Tool Founder ──'),
+                    { name: 'ship        - Shipping and deployment', value: 'ship' },
+                    { name: 'growth      - Growth and marketing', value: 'growth' },
+                    { name: 'support     - Customer experience', value: 'support' },
+                    { name: 'strategy    - Strategy and planning', value: 'strategy' },
+                    { name: 'ops         - Business operations', value: 'ops' },
+                    new inquirer.Separator('───────────────────'),
+                    { name: 'Custom...', value: '__custom__' },
+                ],
+                default: flags.category || template?.defaultCategory || '',
+            },
+            {
+                type: 'input',
+                name: 'customCategory',
+                message: 'Enter custom category:',
+                when: (answers) => answers.categoryChoice === '__custom__',
+                validate: (input) => input.length > 0 || 'Category is required when choosing custom',
+            },
+        ]);
+        // Resolve category from choice or custom input
+        const category = answers.categoryChoice === '__custom__'
+            ? answers.customCategory
+            : answers.categoryChoice || undefined;
+        // Prompt for structured description (use template description if available)
+        const description = await this.promptStructuredDescription(flags.description || template?.descriptionTemplate);
+        // Parse labels from flag or use template defaults
+        const labels = flags.labels
+            ? flags.labels.split(',').map(l => l.trim()).filter(l => l)
+            : template?.defaultLabels;
+        return {
+            title: answers.title,
+            statusName: answers.column,
+            priority: answers.priority || undefined,
+            category,
+            description: description || undefined,
+            id: flags.id,
+            epicId: flags.epic,
+            labels,
+        };
+    }
+    async promptStructuredDescription(existingDescription) {
+        // If description already provided via flag, use it
+        if (existingDescription) {
+            return existingDescription;
+        }
+        this.log(styles.muted('\n─── Ticket Description (for agent execution) ───'));
+        const descAnswers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'what',
+                message: 'What is the concrete outcome? (one sentence):',
+                validate: (input) => input.length > 0 || 'Outcome is required - what does success look like?',
+            },
+            {
+                type: 'input',
+                name: 'doneWhen',
+                message: 'Done when (acceptance criteria):',
+            },
+            {
+                type: 'input',
+                name: 'context',
+                message: 'Context (files, patterns, hints - optional):',
+                default: '',
+            },
+            {
+                type: 'input',
+                name: 'notInScope',
+                message: 'Not in scope (explicit exclusions - optional):',
+                default: '',
+            },
+        ]);
+        // Build structured description
+        const parts = [];
+        parts.push(`## What\n${descAnswers.what}`);
+        if (descAnswers.doneWhen.trim()) {
+            // Ensure each line in doneWhen starts with - [ ] if it doesn't already
+            const criteria = descAnswers.doneWhen
+                .split('\n')
+                .map(line => line.trim())
+                .filter(line => line.length > 0)
+                .map(line => {
+                if (line.startsWith('- [ ]') || line.startsWith('- [x]')) {
+                    return line;
+                }
+                if (line.startsWith('-')) {
+                    return `- [ ]${line.slice(1)}`;
+                }
+                return `- [ ] ${line}`;
+            })
+                .join('\n');
+            parts.push(`## Done when\n${criteria}`);
+        }
+        if (descAnswers.context.trim()) {
+            parts.push(`## Context\n${descAnswers.context}`);
+        }
+        if (descAnswers.notInScope.trim()) {
+            parts.push(`## Not in scope\n${descAnswers.notInScope}`);
+        }
+        return parts.join('\n\n');
+    }
+}

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

@@ -0,0 +1,16 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TicketDelete extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticketId: 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>;
+        bulk: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private executeBulk;
+}