@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/spec/plan.js

@@ -0,0 +1,108 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class SpecPlan extends PMOCommand {
+    static description = 'Generate tickets from spec by comparing ideal state vs codebase (uses LLM)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> user-authentication',
+        '<%= config.bin %> <%= command.id %> --spec api-design --dry-run',
+    ];
+    static args = {
+        spec: Args.string({
+            description: 'Spec ID',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        spec: Flags.string({
+            char: 's',
+            description: 'Spec ID',
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Show what would be created without creating tickets',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(SpecPlan);
+        // 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('spec plan', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get spec ID
+        let specId = args.spec || flags.spec;
+        if (!specId) {
+            // List specs and prompt for selection
+            const specs = await this.storage.listSpecs();
+            if (specs.length === 0) {
+                return handleError('NO_SPECS', 'No specs found. Create a spec first with "prlt spec create".');
+            }
+            // In JSON mode, output spec selection prompt
+            if (jsonMode) {
+                const specChoices = specs.map(s => ({
+                    name: `${s.title} [${s.status}]${s.type ? ` (${s.type})` : ''}`,
+                    value: s.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'spec', 'Select spec to plan:', specChoices), createMetadata('spec plan', flags));
+                return;
+            }
+            const { selectedSpec } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedSpec',
+                    message: 'Select spec to plan:',
+                    choices: specs.map(s => ({
+                        name: `${s.title} [${s.status}]${s.type ? ` (${s.type})` : ''}`,
+                        value: s.id,
+                    })),
+                },
+            ]);
+            specId = selectedSpec;
+        }
+        // Get the spec
+        const spec = await this.storage.getSpec(specId);
+        if (!spec) {
+            this.error(`Spec not found: ${specId}`);
+        }
+        this.log(styles.header(`\n📋 Planning from spec: ${spec.title}`));
+        this.log('');
+        // TODO: Call LLM to compare spec vs codebase and generate tickets
+        // For now, just show the spec content
+        this.log(styles.muted('Spec content:'));
+        if (spec.problem) {
+            this.log(styles.muted(`\nProblem:`));
+            this.log(`  ${spec.problem}`);
+        }
+        if (spec.solution) {
+            this.log(styles.muted(`\nSolution:`));
+            this.log(`  ${spec.solution}`);
+        }
+        if (spec.acceptanceCriteria) {
+            this.log(styles.muted(`\nAcceptance Criteria:`));
+            this.log(`  ${spec.acceptanceCriteria}`);
+        }
+        this.log('');
+        this.log(styles.warning('LLM-based ticket generation not yet implemented.'));
+        this.log(styles.muted('This command will:'));
+        this.log(styles.muted('  1. Read the spec (ideal state)'));
+        this.log(styles.muted('  2. Analyze the codebase (current state)'));
+        this.log(styles.muted('  3. Generate tickets for the delta'));
+        this.log('');
+        if (flags['dry-run']) {
+            this.log(styles.muted('(dry-run mode - no tickets would be created)'));
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SpecTicket extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        specId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ticket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        spec: 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 listAvailableSpecs;
+    private findSpecFile;
+}

package/dist/commands/spec/ticket.js

@@ -0,0 +1,160 @@
+import { Flags, Args } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class SpecTicket extends PMOCommand {
+    static description = 'Assign a ticket to a spec document';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> PRLT-001 user-authentication',
+        '<%= config.bin %> <%= command.id %> --ticket PRLT-001 --spec api-design',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID',
+            required: false,
+        }),
+        specId: Args.string({
+            description: 'Spec ID (filename without .md)',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        ticket: Flags.string({
+            char: 't',
+            description: 'Ticket ID',
+        }),
+        spec: Flags.string({
+            char: 's',
+            description: 'Spec ID (filename without .md)',
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(SpecTicket);
+        // This command requires project context
+        const projectId = await this.requireProject();
+        // 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('spec ticket', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get ticket ID
+        let ticketId = args.ticketId || flags.ticket;
+        if (!ticketId) {
+            const tickets = await this.storage.listTickets(projectId);
+            if (tickets.length === 0) {
+                return handleError('NO_TICKETS', 'No tickets found. Create one first with: prlt ticket create');
+            }
+            // In JSON mode, output ticket selection prompt
+            if (jsonMode) {
+                const ticketChoices = tickets.map(t => ({ name: `${t.id}: ${t.title}`, value: t.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'ticketId', 'Select ticket to link:', ticketChoices), createMetadata('spec ticket', flags));
+                return;
+            }
+            const { selectedTicket } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedTicket',
+                    message: 'Select ticket to link:',
+                    choices: tickets.map(t => ({ name: `${t.id}: ${t.title}`, value: t.id })),
+                }]);
+            ticketId = selectedTicket;
+        }
+        if (!ticketId) {
+            return handleError('NO_TICKET_SELECTED', 'No ticket selected');
+        }
+        // Get ticket
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            const projectName = await this.getProjectName(projectId);
+            return handleError('TICKET_NOT_FOUND', `Ticket "${ticketId}" not found in project "${projectName}"`);
+        }
+        // Get spec ID
+        let specId = args.specId || flags.spec;
+        if (!specId) {
+            const specs = await this.listAvailableSpecs(this.pmoPath, projectId);
+            if (specs.length === 0) {
+                return handleError('NO_SPECS', 'No specs found. Create one first with: prlt spec create');
+            }
+            // In JSON mode, output spec selection prompt
+            if (jsonMode) {
+                const specChoices = specs.map(s => ({ name: `${s.name} (${s.status})`, value: s.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'specId', 'Select spec to link:', specChoices), createMetadata('spec ticket', flags));
+                return;
+            }
+            const { selectedSpec } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedSpec',
+                    message: 'Select spec to link:',
+                    choices: specs.map(s => ({ name: `${s.name} (${s.status})`, value: s.id })),
+                }]);
+            specId = selectedSpec;
+        }
+        if (!specId) {
+            this.error('No spec selected');
+        }
+        // Verify spec exists
+        const specPath = this.findSpecFile(this.pmoPath, projectId, specId);
+        if (!specPath) {
+            const projectName = await this.getProjectName(projectId);
+            this.error(`Spec "${specId}" not found in project "${projectName}"`);
+        }
+        // Check if already linked
+        if (ticket.specId === specId) {
+            this.log(styles.warning(`Ticket "${ticketId}" is already linked to spec "${specId}"`));
+            return;
+        }
+        // Warn if ticket already has a different spec
+        if (ticket.specId && ticket.specId !== specId) {
+            this.log(styles.warning(`Ticket "${ticketId}" is currently linked to spec "${ticket.specId}"`));
+            this.log(styles.muted(`This will replace the existing spec link.`));
+        }
+        // Set spec on ticket (single spec per ticket)
+        await this.storage.updateTicket(ticketId, { specId });
+        // Auto-export to board.md
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\n✅ Linked ticket "${styles.emphasis(ticketId)}" to spec "${styles.emphasis(specId)}"`));
+        this.log(styles.muted(`\nView ticket:`));
+        this.log(styles.muted(`  prlt ticket view ${ticketId}`));
+    }
+    async listAvailableSpecs(pmoPath, projectId) {
+        const specsBasePath = path.join(pmoPath, 'projects', projectId, 'specs');
+        const specs = [];
+        if (!fs.existsSync(specsBasePath)) {
+            return specs;
+        }
+        for (const status of ['active', 'draft', 'archived']) {
+            const statusPath = path.join(specsBasePath, status);
+            if (!fs.existsSync(statusPath)) {
+                continue;
+            }
+            const files = fs.readdirSync(statusPath).filter(f => f.endsWith('.md'));
+            for (const file of files) {
+                const id = path.basename(file, '.md');
+                specs.push({ id, name: id, status });
+            }
+        }
+        return specs;
+    }
+    findSpecFile(pmoPath, projectId, specId) {
+        const specsBasePath = path.join(pmoPath, 'projects', projectId, 'specs');
+        for (const status of ['active', 'draft', 'archived']) {
+            const specPath = path.join(specsBasePath, status, `${specId}.md`);
+            if (fs.existsSync(specPath)) {
+                return specPath;
+            }
+        }
+        return null;
+    }
+}

package/dist/commands/spec/view.d.ts

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

package/dist/commands/spec/view.js

@@ -0,0 +1,163 @@
+import { Flags, Args } from '@oclif/core';
+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 SpecView extends PMOCommand {
+    static description = 'View a spec and its linked tickets';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> user-authentication',
+        '<%= config.bin %> <%= command.id %> --spec api-design',
+    ];
+    static args = {
+        spec: Args.string({
+            description: 'Spec ID',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        spec: Flags.string({
+            char: 's',
+            description: 'Spec ID',
+        }),
+        full: Flags.boolean({
+            char: 'f',
+            description: 'Show all spec sections',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(SpecView);
+        // This command requires project context for listing linked tickets
+        const projectId = await this.requireProject();
+        // 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('spec view', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get spec ID
+        let specId = args.spec || flags.spec;
+        if (!specId) {
+            const specs = await this.storage.listSpecs();
+            if (specs.length === 0) {
+                return handleError('NO_SPECS', 'No specs found. Create one first with: prlt spec create');
+            }
+            const selected = await this.selectFromList({
+                message: 'Select spec to view:',
+                items: specs,
+                getName: (s) => `${s.title} [${s.status}]${s.type ? ` (${s.type})` : ''}`,
+                getValue: (s) => s.id,
+                getCommand: (s) => `prlt spec view ${s.id} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'spec view' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            specId = selected;
+        }
+        // Get the spec
+        const spec = await this.storage.getSpec(specId);
+        if (!spec) {
+            this.error(`Spec not found: ${specId}`);
+        }
+        // Get linked tickets
+        const tickets = await this.storage.getTicketsForSpec(projectId, spec.id);
+        // Get dependencies
+        const dependencies = await this.storage.getSpecDependencies(spec.id);
+        const dependents = await this.storage.getSpecDependents(spec.id);
+        // Display spec info
+        this.log(styles.title(`\n📄 ${spec.title}`));
+        this.log(styles.muted('═'.repeat(60)));
+        this.log(styles.muted(`ID: ${spec.id}`));
+        this.log(styles.muted(`Status: ${spec.status}`));
+        if (spec.type)
+            this.log(styles.muted(`Type: ${spec.type}`));
+        if (spec.tags && spec.tags.length > 0) {
+            this.log(styles.muted(`Tags: ${spec.tags.join(', ')}`));
+        }
+        this.log(styles.muted(`Created: ${spec.createdAt.toLocaleDateString()}`));
+        this.log(styles.muted(`Updated: ${spec.updatedAt.toLocaleDateString()}`));
+        // Problem
+        if (spec.problem) {
+            this.log(styles.emphasis('\n## Problem'));
+            this.log(spec.problem);
+        }
+        // Solution
+        if (spec.solution) {
+            this.log(styles.emphasis('\n## Solution'));
+            this.log(spec.solution);
+        }
+        // Decisions (always show)
+        if (spec.decisions) {
+            this.log(styles.emphasis('\n## Decisions'));
+            this.log(spec.decisions);
+        }
+        // Show more sections if --full
+        if (flags.full) {
+            if (spec.notNow) {
+                this.log(styles.emphasis('\n## Not Now'));
+                this.log(spec.notNow);
+            }
+            if (spec.uiUx) {
+                this.log(styles.emphasis('\n## UI/UX'));
+                this.log(spec.uiUx);
+            }
+            if (spec.acceptanceCriteria) {
+                this.log(styles.emphasis('\n## Acceptance Criteria'));
+                this.log(spec.acceptanceCriteria);
+            }
+            if (spec.openQuestions) {
+                this.log(styles.emphasis('\n## Open Questions'));
+                this.log(spec.openQuestions);
+            }
+            if (spec.requirementsFunctional) {
+                this.log(styles.emphasis('\n## Functional Requirements'));
+                this.log(spec.requirementsFunctional);
+            }
+            if (spec.requirementsTechnical) {
+                this.log(styles.emphasis('\n## Technical Requirements'));
+                this.log(spec.requirementsTechnical);
+            }
+            if (spec.context) {
+                this.log(styles.emphasis('\n## Context'));
+                this.log(spec.context);
+            }
+        }
+        // Dependencies
+        if (dependencies.length > 0) {
+            this.log(styles.emphasis(`\n📦 Depends On (${dependencies.length}):`));
+            for (const dep of dependencies) {
+                this.log(`  ${styles.code(dep.id)}: ${dep.title} [${dep.status}]`);
+            }
+        }
+        if (dependents.length > 0) {
+            this.log(styles.emphasis(`\n📦 Depended On By (${dependents.length}):`));
+            for (const dep of dependents) {
+                this.log(`  ${styles.code(dep.id)}: ${dep.title} [${dep.status}]`);
+            }
+        }
+        // Linked tickets
+        if (tickets.length > 0) {
+            this.log(styles.emphasis(`\n🎫 Linked Tickets (${tickets.length}):`));
+            for (const ticket of tickets) {
+                this.log(`  ${styles.code(ticket.id)}: ${ticket.title} [${ticket.status}]`);
+            }
+        }
+        else {
+            this.log(styles.muted('\n🎫 No linked tickets'));
+        }
+        this.log(styles.muted('\n' + '═'.repeat(60)));
+        if (!flags.full) {
+            this.log(styles.muted('Use --full to see all sections'));
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class StatusCreate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        category: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        color: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        default: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private promptStatusData;
+    private getCategoryDescription;
+}

package/dist/commands/status/create.js

@@ -0,0 +1,140 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { STATE_CATEGORY_ORDER } from '../../lib/pmo/types.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class StatusCreate extends PMOCommand {
+    static description = 'Create a new workflow status';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "In Review" --category started',
+        '<%= config.bin %> <%= command.id %> --name "Blocked" --category started --color "#EF4444"',
+        '<%= config.bin %> <%= command.id %> -i  # Interactive mode',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Status name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'Status name',
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'Status category',
+            options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
+        }),
+        color: Flags.string({
+            description: 'Hex color code (e.g., #FF0000)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Status description',
+        }),
+        default: Flags.boolean({
+            description: 'Set as default status for new tickets',
+            default: false,
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode',
+            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(StatusCreate);
+        const projectId = await this.requireProject();
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        let statusData;
+        // Auto-enter interactive mode if any required value is missing
+        const name = args.name || flags.name;
+        if (flags.interactive || !name || !flags.category) {
+            // Build choices once - single source of truth
+            const categoryChoices = STATE_CATEGORY_ORDER.map(cat => ({
+                name: `${cat} - ${this.getCategoryDescription(cat)}`,
+                value: cat,
+            }));
+            // Define fields once - single source of truth for both JSON and interactive modes
+            const fields = [
+                { type: 'input', name: 'name', message: 'Status name:', default: name || flags.name },
+                { type: 'list', name: 'category', message: 'Category:', choices: categoryChoices, default: flags.category || 'backlog' },
+                { type: 'input', name: 'color', message: 'Color (hex, optional):', default: flags.color },
+                { type: 'input', name: 'description', message: 'Description (optional):', default: flags.description },
+                { type: 'confirm', name: 'isDefault', message: 'Set as default status for new tickets?', default: flags.default || false },
+            ];
+            // In JSON mode, output form prompts
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('status create', flags));
+            }
+            statusData = await this.promptStatusData(fields);
+        }
+        else {
+            statusData = {
+                name,
+                category: flags.category,
+                color: flags.color,
+                description: flags.description,
+                isDefault: flags.default,
+            };
+        }
+        const status = await this.storage.createStatus(projectId, {
+            name: statusData.name,
+            category: statusData.category,
+            color: statusData.color,
+            description: statusData.description,
+            isDefault: statusData.isDefault,
+        });
+        const projectName = await this.getProjectName(projectId);
+        this.log(styles.success(`\nCreated status "${styles.emphasis(status.name)}"`));
+        this.log(styles.muted(`  Category: ${status.category}`));
+        this.log(styles.muted(`  Project: ${projectName}`));
+        if (status.color) {
+            this.log(styles.muted(`  Color: ${status.color}`));
+        }
+        if (status.isDefault) {
+            this.log(styles.muted(`  Default: yes`));
+        }
+    }
+    async promptStatusData(fields) {
+        // Build inquirer prompts from fields, adding validators
+        const answers = await inquirer.prompt(fields.map(field => ({
+            ...field,
+            validate: field.name === 'name'
+                ? ((input) => input.length > 0 || 'Name is required')
+                : field.name === 'color'
+                    ? ((input) => {
+                        if (!input)
+                            return true;
+                        return /^#[0-9A-Fa-f]{6}$/.test(input) || 'Invalid hex color (e.g., #FF0000)';
+                    })
+                    : undefined,
+        })));
+        return {
+            name: answers.name,
+            category: answers.category,
+            color: answers.color || undefined,
+            description: answers.description || undefined,
+            isDefault: answers.isDefault,
+        };
+    }
+    getCategoryDescription(category) {
+        const descriptions = {
+            triage: 'Inbox - needs review before entering workflow',
+            backlog: 'Not yet scheduled for work',
+            unstarted: 'Scheduled but work hasn\'t begun',
+            started: 'Work is actively in progress',
+            completed: 'Work finished successfully',
+            canceled: 'Work won\'t be done',
+        };
+        return descriptions[category];
+    }
+}

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

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