@proletariat/cli 0.1.4 → 0.3.0

package/dist/commands/ticket/delete.js

@@ -0,0 +1,178 @@
+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 TicketDelete extends PMOCommand {
+    static description = 'Delete ticket(s) permanently';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TICK-001',
+        '<%= config.bin %> <%= command.id %> TICK-001 --force',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+        '<%= config.bin %> <%= command.id %> --bulk',
+        '<%= config.bin %> <%= command.id %> --json  # Output choices as JSON',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID to delete - 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,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        bulk: Flags.boolean({
+            char: 'b',
+            description: 'Enable bulk mode to delete multiple tickets',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketDelete);
+        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 delete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get all tickets for selection
+        const allTickets = await this.storage.listTickets(projectId);
+        if (allTickets.length === 0) {
+            return handleError('NO_TICKETS', 'No tickets found.');
+        }
+        // Bulk mode
+        if (flags.bulk) {
+            await this.executeBulk(allTickets, flags.force);
+            return;
+        }
+        // Single ticket mode
+        let ticketId = args.ticketId;
+        if (!ticketId) {
+            // Use helper for ticket selection (handles JSON mode automatically)
+            const selected = await this.selectFromList({
+                message: 'Select ticket to delete:',
+                items: allTickets,
+                getName: (t) => `${t.id} - ${t.title} (${t.statusName})`,
+                getValue: (t) => t.id,
+                getCommand: (t) => `prlt ticket delete ${t.id} --force --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'ticket delete' } : null,
+            });
+            if (!selected) {
+                return; // Cancelled or JSON mode (already exited)
+            }
+            ticketId = selected;
+        }
+        // Get ticket to show details in confirmation
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            this.error(`Ticket "${ticketId}" not found.`);
+        }
+        // Get board for project name
+        const board = await this.storage.getBoard(ticket.projectId);
+        // Confirmation prompt (unless --force)
+        if (!flags.force) {
+            this.log(`\nDelete ticket ${styles.emphasis(ticketId)}?`);
+            this.log(`  Title: ${ticket.title}`);
+            this.log(`  Project: ${board.name}`);
+            this.log(`  Status: ${ticket.statusName}`);
+            const { confirmed } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirmed',
+                    message: 'Are you sure?',
+                    choices: [
+                        { name: 'No, cancel', value: false },
+                        { name: 'Yes, delete', value: true },
+                    ],
+                    default: 0,
+                }]);
+            if (!confirmed) {
+                this.log(styles.warning('Deletion cancelled.'));
+                return;
+            }
+        }
+        // Delete ticket
+        await this.storage.deleteTicket(ticketId);
+        // Auto-export to board.md after write
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\n✅ Ticket ${styles.emphasis(ticketId)} deleted`));
+        this.log(styles.muted('   Removed from database and board'));
+    }
+    async executeBulk(allTickets, force) {
+        this.log(styles.emphasis('🗑️  Delete Multiple Tickets\n'));
+        // Select tickets to delete
+        const { selectedTickets } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedTickets',
+                message: 'Select tickets to DELETE:',
+                choices: allTickets.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.warning('\nThis will PERMANENTLY DELETE:'));
+            for (const ticketId of selectedTickets) {
+                const ticket = allTickets.find(t => t.id === ticketId);
+                this.log(styles.primary(`  • ${ticketId}: ${ticket?.title}`));
+            }
+            this.log('');
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: 'Are you sure? This cannot be undone.',
+                    choices: [
+                        { name: 'No, cancel', value: false },
+                        { name: 'Yes, DELETE tickets', value: true }
+                    ],
+                    default: 0
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Deletion cancelled.'));
+                return;
+            }
+        }
+        this.log('');
+        // Delete each ticket
+        let successCount = 0;
+        let failCount = 0;
+        for (const ticketId of selectedTickets) {
+            try {
+                await this.storage.deleteTicket(ticketId);
+                this.log(styles.success(`Deleted ${ticketId}`));
+                successCount++;
+            }
+            catch (error) {
+                this.log(styles.error(`Failed to delete ${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(`Deleted ${successCount} ticket(s)`));
+        }
+        if (failCount > 0) {
+            this.log(styles.error(`Failed to delete ${failCount} ticket(s)`));
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TicketEdit extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        title: 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>;
+        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>;
+        owner: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        assignee: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'add-subtask': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'clear-subtasks': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'add-label': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'remove-label': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'add-ac': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'clear-ac': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        interactive: 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 promptForEdits;
+}

package/dist/commands/ticket/edit.js

@@ -0,0 +1,322 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class TicketEdit extends PMOCommand {
+    static description = 'Edit an existing ticket';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TICK-001',
+        '<%= config.bin %> <%= command.id %> TICK-001 --title "New title"',
+        '<%= config.bin %> <%= command.id %> TICK-001 --priority HIGH --category bug',
+        '<%= config.bin %> <%= command.id %> TICK-001 --add-subtask "Implement feature" --add-subtask "Write tests"',
+        '<%= config.bin %> <%= command.id %> TICK-001 --owner "john" --assignee "agent-1"',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID to edit - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        title: Flags.string({
+            char: 't',
+            description: 'New ticket title',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'New ticket description',
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'New ticket priority',
+            options: [...PRIORITIES, 'none'],
+        }),
+        category: Flags.string({
+            description: 'New ticket category',
+        }),
+        owner: Flags.string({
+            char: 'o',
+            description: 'Ticket owner (human responsible)',
+        }),
+        assignee: Flags.string({
+            char: 'a',
+            description: 'Ticket assignee (who executes)',
+        }),
+        'add-subtask': Flags.string({
+            description: 'Add a subtask (can be used multiple times)',
+            multiple: true,
+        }),
+        'clear-subtasks': Flags.boolean({
+            description: 'Clear all existing subtasks before adding new ones',
+            default: false,
+        }),
+        'add-label': Flags.string({
+            description: 'Add a label (can be used multiple times)',
+            multiple: true,
+        }),
+        'remove-label': Flags.string({
+            description: 'Remove a label',
+            multiple: true,
+        }),
+        'add-ac': Flags.string({
+            description: 'Add an acceptance criterion (can be used multiple times)',
+            multiple: true,
+        }),
+        'clear-ac': Flags.boolean({
+            description: 'Clear all existing acceptance criteria before adding new ones',
+            default: false,
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode - prompts for all fields',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketEdit);
+        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 edit', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get ticketId - prompt if not provided
+        let ticketId = args.ticketId;
+        if (!ticketId) {
+            // Get all tickets for selection
+            const allTickets = await this.storage.listTickets(projectId);
+            if (allTickets.length === 0) {
+                return handleError('NO_TICKETS', 'No tickets found. Create a ticket first with "prlt ticket create".');
+            }
+            // Use helper for ticket selection (handles JSON mode automatically)
+            const selected = await this.selectFromList({
+                message: 'Select ticket to edit:',
+                items: allTickets,
+                getName: (t) => `${t.id} - ${t.title} (${t.statusName})`,
+                getValue: (t) => t.id,
+                getCommand: (t) => `prlt ticket edit ${t.id} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'ticket edit' } : null,
+            });
+            if (!selected) {
+                return; // Cancelled or JSON mode (already exited)
+            }
+            ticketId = selected;
+        }
+        // Get current ticket
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            this.error(`Ticket "${ticketId}" not found.`);
+        }
+        // Determine what to update
+        let updates = {};
+        const hasFlags = flags.title || flags.description || flags.priority || flags.category ||
+            flags.owner || flags.assignee || flags['add-subtask'] || flags['clear-subtasks'] ||
+            flags['add-label'] || flags['remove-label'] || flags['add-ac'] || flags['clear-ac'];
+        if (flags.interactive || !hasFlags) {
+            // Interactive mode - prompt for all editable fields
+            const board = await this.storage.getBoard(ticket.projectId);
+            const columns = board.columns.map(col => col.name);
+            updates = await this.promptForEdits(ticket, columns);
+        }
+        else {
+            // Use flag values
+            if (flags.title)
+                updates.title = flags.title;
+            if (flags.description)
+                updates.description = flags.description;
+            if (flags.priority) {
+                updates.priority = flags.priority === 'none' ? undefined : flags.priority;
+            }
+            if (flags.category)
+                updates.category = flags.category;
+            if (flags.owner)
+                updates.owner = flags.owner;
+            if (flags.assignee)
+                updates.assignee = flags.assignee;
+        }
+        // Handle subtasks
+        let subtasksChanged = false;
+        if (flags['clear-subtasks']) {
+            // Clear all subtasks first - get from ticket object
+            for (const subtask of ticket.subtasks) {
+                await this.storage.removeSubtask(ticketId, subtask.id);
+            }
+            subtasksChanged = true;
+        }
+        if (flags['add-subtask'] && flags['add-subtask'].length > 0) {
+            for (const subtaskTitle of flags['add-subtask']) {
+                await this.storage.addSubtask(ticketId, subtaskTitle);
+            }
+            subtasksChanged = true;
+        }
+        // Handle labels
+        let labelsChanged = false;
+        let currentLabels = [...ticket.labels];
+        if (flags['remove-label'] && flags['remove-label'].length > 0) {
+            currentLabels = currentLabels.filter(l => !flags['remove-label'].includes(l));
+            labelsChanged = true;
+        }
+        if (flags['add-label'] && flags['add-label'].length > 0) {
+            for (const label of flags['add-label']) {
+                if (!currentLabels.includes(label)) {
+                    currentLabels.push(label);
+                    labelsChanged = true;
+                }
+            }
+        }
+        // Handle acceptance criteria
+        let acChanged = false;
+        if (flags['clear-ac']) {
+            await this.storage.clearAcceptanceCriteria(ticketId);
+            acChanged = true;
+        }
+        if (flags['add-ac'] && flags['add-ac'].length > 0) {
+            for (const criterion of flags['add-ac']) {
+                await this.storage.addAcceptanceCriterion(ticketId, criterion);
+            }
+            acChanged = true;
+        }
+        // Check if anything changed
+        const hasChanges = Object.keys(updates).length > 0 || subtasksChanged || labelsChanged || acChanged;
+        if (!hasChanges) {
+            this.log(styles.muted('\nNo changes made.'));
+            return;
+        }
+        // Update the ticket with labels if changed
+        if (labelsChanged) {
+            updates.labels = currentLabels;
+        }
+        // Update the ticket
+        const updatedTicket = await this.storage.updateTicket(ticketId, updates);
+        // Auto-export to board.md
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        // Display updated ticket
+        this.log(styles.success(`\n✅ Updated ticket ${styles.emphasis(updatedTicket.id)}`));
+        const changedFields = [];
+        if (updates.title)
+            changedFields.push(`Title: ${updatedTicket.title}`);
+        if (updates.description !== undefined)
+            changedFields.push(`Description: ${updatedTicket.description || '(cleared)'}`);
+        if (updates.priority !== undefined)
+            changedFields.push(`Priority: ${updatedTicket.priority || 'none'}`);
+        if (updates.category !== undefined)
+            changedFields.push(`Category: ${updatedTicket.category || 'none'}`);
+        if (updates.owner !== undefined)
+            changedFields.push(`Owner: ${updatedTicket.owner || 'none'}`);
+        if (updates.assignee !== undefined)
+            changedFields.push(`Assignee: ${updatedTicket.assignee || 'none'}`);
+        if (subtasksChanged || acChanged) {
+            // Re-fetch ticket to get updated subtasks and AC
+            const refreshedTicket = await this.storage.getTicket(ticketId);
+            if (subtasksChanged) {
+                changedFields.push(`Subtasks: ${refreshedTicket?.subtasks.length || 0} items`);
+            }
+            if (acChanged) {
+                changedFields.push(`Acceptance Criteria: ${refreshedTicket?.acceptanceCriteria?.length || 0} items`);
+            }
+        }
+        if (labelsChanged)
+            changedFields.push(`Labels: ${currentLabels.join(', ') || 'none'}`);
+        for (const field of changedFields) {
+            this.log(styles.muted(`   ${field}`));
+        }
+        this.log('');
+    }
+    async promptForEdits(ticket, _columns) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'title',
+                message: 'Title:',
+                default: ticket.title,
+                validate: (input) => input.length > 0 || 'Title is required',
+            },
+            {
+                type: 'editor',
+                name: 'description',
+                message: 'Description (opens $EDITOR for multiline input):',
+                default: ticket.description || '',
+                waitForUseInput: false,
+            },
+            {
+                type: 'list',
+                name: 'priority',
+                message: 'Priority:',
+                choices: [
+                    { name: 'None', value: '' },
+                    ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                ],
+                default: ticket.priority || '',
+            },
+            {
+                type: 'list',
+                name: 'categoryChoice',
+                message: 'Category:',
+                choices: [
+                    { name: '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: ticket.category || '',
+            },
+            {
+                type: 'input',
+                name: 'customCategory',
+                message: 'Enter custom category:',
+                when: (answers) => answers.categoryChoice === '__custom__',
+                validate: (input) => input.length > 0 || 'Category is required when choosing custom',
+            },
+        ]);
+        // Build updates object with only changed fields
+        const updates = {};
+        if (answers.title !== ticket.title) {
+            updates.title = answers.title;
+        }
+        if (answers.description !== (ticket.description || '')) {
+            updates.description = answers.description || undefined;
+        }
+        if (answers.priority !== (ticket.priority || '')) {
+            updates.priority = answers.priority || undefined;
+        }
+        const newCategory = answers.categoryChoice === '__custom__'
+            ? answers.customCategory
+            : answers.categoryChoice;
+        if (newCategory !== (ticket.category || '')) {
+            updates.category = newCategory || undefined;
+        }
+        return updates;
+    }
+}

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

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