@proletariat/cli 0.1.4 → 0.3.0

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

@@ -0,0 +1,95 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+export default class PhaseTemplateList extends PMOCommand {
+    static description = 'List available phase templates';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --builtin  # Only built-in templates',
+        '<%= config.bin %> <%= command.id %> --custom   # Only custom templates',
+    ];
+    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(PhaseTemplateList);
+        let filter;
+        if (flags.builtin)
+            filter = { isBuiltin: true };
+        if (flags.custom)
+            filter = { isBuiltin: false };
+        const templates = await this.storage.listPhaseTemplates(filter);
+        if (flags.json) {
+            this.log(JSON.stringify(templates, null, 2));
+            return;
+        }
+        if (templates.length === 0) {
+            this.log(styles.muted('\nNo phase templates found.'));
+            return;
+        }
+        this.log(`\n📋 ${styles.emphasis('Phase 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('Apply a template: prlt phase 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)}`);
+        }
+        // Group phases by category for display
+        const categoryEmoji = {
+            triage: '📬',
+            backlog: '📥',
+            unstarted: '📋',
+            started: '🚀',
+            completed: '✅',
+            canceled: '🚫',
+        };
+        const phasesByCategory = new Map();
+        for (const phase of template.phases) {
+            const existing = phasesByCategory.get(phase.category) || [];
+            existing.push(phase.name);
+            phasesByCategory.set(phase.category, existing);
+        }
+        const phaseParts = [];
+        for (const [category, names] of phasesByCategory) {
+            const emoji = categoryEmoji[category];
+            phaseParts.push(`${emoji} ${names.join(', ')}`);
+        }
+        this.log(`    ${styles.muted(phaseParts.join(' → '))}`);
+    }
+}

package/dist/commands/phase/template/update.d.ts

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class PhaseTemplateUpdate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: 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>;
+        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>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/phase/template/update.js

@@ -0,0 +1,89 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+export default class PhaseTemplateUpdate extends PMOCommand {
+    static description = 'Update a phase template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-template --name "New Name"',
+        '<%= config.bin %> <%= command.id %> my-template --description "Updated description"',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Template ID to update',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'New template name',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'New template description',
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(PhaseTemplateUpdate);
+        // Get template ID - prompt for selection if not provided
+        let templateId = args.id;
+        if (!templateId) {
+            const templates = await this.storage.listPhaseTemplates();
+            const editableTemplates = templates.filter(t => !t.isBuiltin);
+            if (editableTemplates.length === 0) {
+                this.error('No editable phase templates found (built-in templates cannot be updated).');
+            }
+            const { selectedTemplate } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedTemplate',
+                    message: 'Select a template to update:',
+                    choices: editableTemplates.map(t => ({
+                        name: `${t.name}${t.description ? ` - ${t.description}` : ''}`,
+                        value: t.id,
+                    })),
+                }]);
+            templateId = selectedTemplate;
+        }
+        // If no flags provided, prompt for what to update
+        let newName = flags.name;
+        let newDescription = flags.description;
+        if (!newName && newDescription === undefined) {
+            const { updateName } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'updateName',
+                    message: 'New name (leave empty to keep current):',
+                }]);
+            if (updateName)
+                newName = updateName;
+            const { updateDesc } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'updateDesc',
+                    message: 'New description (leave empty to keep current):',
+                }]);
+            if (updateDesc)
+                newDescription = updateDesc;
+            if (!newName && !newDescription) {
+                this.log(styles.muted('No changes made.'));
+                return;
+            }
+        }
+        const changes = {};
+        if (newName)
+            changes.name = newName;
+        if (newDescription !== undefined)
+            changes.description = newDescription;
+        const template = await this.storage.updatePhaseTemplate(templateId, changes);
+        this.log(styles.success(`\nUpdated phase template "${styles.emphasis(template.name)}"`));
+        if (flags.name) {
+            this.log(styles.muted(`  Name: ${template.name}`));
+        }
+        if (flags.description !== undefined) {
+            this.log(styles.muted(`  Description: ${template.description || '(none)'}`));
+        }
+    }
+}

package/dist/commands/phase/update.d.ts

@@ -0,0 +1,23 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class PhaseUpdate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: 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>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private promptUpdates;
+}

package/dist/commands/phase/update.js

@@ -0,0 +1,174 @@
+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, outputErrorAsJson, createMetadata, buildPromptConfig, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class PhaseUpdate extends PMOCommand {
+    static description = 'Update a project lifecycle phase';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> active --name "In Development"',
+        '<%= config.bin %> <%= command.id %> idea --color "#9333EA"',
+        '<%= config.bin %> <%= command.id %> planned --default',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Phase ID - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'New name',
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'New category',
+            options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
+        }),
+        color: Flags.string({
+            description: 'New hex color',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'New description',
+        }),
+        default: Flags.boolean({
+            description: 'Set as default phase',
+        }),
+        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,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false }; // Phases are workspace-scoped, no project selection needed
+    }
+    async execute() {
+        const { args, flags } = await this.parse(PhaseUpdate);
+        // 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('phase update', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get phase ID - prompt if not provided
+        let phaseId = args.id;
+        if (!phaseId) {
+            const phases = await this.storage.listPhases();
+            if (phases.length === 0) {
+                return handleError('NO_PHASES', 'No phases found. Create a phase first with "prlt phase create".');
+            }
+            // In JSON mode, output phase selection prompt
+            if (jsonMode) {
+                const phaseChoices = phases.map(p => ({
+                    name: `${p.name} (${p.category})`,
+                    value: p.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'phaseId', 'Select phase to update:', phaseChoices), createMetadata('phase update', flags));
+                return;
+            }
+            const { selectedId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedId',
+                    message: 'Select phase to update:',
+                    choices: phases.map(p => ({
+                        name: `${p.name} (${p.category})`,
+                        value: p.id,
+                    })),
+                }]);
+            phaseId = selectedId;
+        }
+        const existing = await this.storage.getPhase(phaseId);
+        if (!existing) {
+            return handleError('PHASE_NOT_FOUND', `Phase "${phaseId}" not found.`);
+        }
+        let updates;
+        // Check if any change flags were provided
+        const hasChangeFlags = flags.name !== undefined ||
+            flags.category !== undefined ||
+            flags.color !== undefined ||
+            flags.description !== undefined ||
+            flags.default !== undefined;
+        // Auto-enter interactive mode if no change flags provided
+        if (flags.interactive || !hasChangeFlags) {
+            // Define labels and choices once - single source of truth
+            const categoryLabels = {
+                triage: 'Triage - Inbox, needs review',
+                backlog: 'Backlog - Not yet scheduled for work',
+                unstarted: 'Unstarted - Scheduled but work hasn\'t begun',
+                started: 'Started - Work is actively in progress',
+                completed: 'Completed - Work finished successfully',
+                canceled: 'Canceled - Work won\'t be done',
+            };
+            const categoryChoices = STATE_CATEGORY_ORDER.map(cat => ({ name: categoryLabels[cat], value: cat }));
+            // Define fields once - single source of truth for both JSON and interactive modes
+            const fields = [
+                { type: 'input', name: 'name', message: 'Name:', default: existing.name },
+                { type: 'list', name: 'category', message: 'Category:', choices: categoryChoices, default: existing.category },
+                { type: 'input', name: 'color', message: 'Color (hex):', default: existing.color || '' },
+                { type: 'input', name: 'description', message: 'Description:', default: existing.description || '' },
+                { type: 'confirm', name: 'isDefault', message: 'Default for new projects?', default: existing.isDefault || false },
+            ];
+            // In JSON mode, output form prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('phase update', flags));
+            }
+            updates = await this.promptUpdates(fields, existing);
+        }
+        else {
+            updates = {};
+            if (flags.name)
+                updates.name = flags.name;
+            if (flags.category)
+                updates.category = flags.category;
+            if (flags.color)
+                updates.color = flags.color;
+            if (flags.description)
+                updates.description = flags.description;
+            if (flags.default !== undefined)
+                updates.isDefault = flags.default;
+        }
+        const phase = await this.storage.updatePhase(phaseId, updates);
+        this.log(styles.success(`\nUpdated phase "${styles.emphasis(phase.name)}"`));
+        this.log(styles.muted(`  ID: ${phase.id}`));
+        this.log(styles.muted(`  Category: ${phase.category}`));
+        if (phase.color) {
+            this.log(styles.muted(`  Color: ${phase.color}`));
+        }
+        if (phase.description) {
+            this.log(styles.muted(`  Description: ${phase.description}`));
+        }
+        if (phase.isDefault) {
+            this.log(styles.muted(`  Default: Yes`));
+        }
+    }
+    async promptUpdates(fields, existing) {
+        // Build inquirer prompts from fields
+        const answers = await inquirer.prompt(fields);
+        const updates = {};
+        if (answers.name !== existing.name)
+            updates.name = answers.name;
+        if (answers.category !== existing.category)
+            updates.category = answers.category;
+        if (answers.color !== (existing.color || ''))
+            updates.color = answers.color || undefined;
+        if (answers.description !== (existing.description || ''))
+            updates.description = answers.description || undefined;
+        if (answers.isDefault !== (existing.isDefault || false))
+            updates.isDefault = answers.isDefault;
+        return updates;
+    }
+}

package/dist/commands/pmo/init.d.ts

@@ -0,0 +1,25 @@
+import { Command } from '@oclif/core';
+export default class PMOInit extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        location: 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>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Create standalone mini-HQ structure for PMO outside of an HQ
+     */
+    private createStandaloneHQ;
+    private findHQRoot;
+    private promptReinitialize;
+    private deletePMO;
+    private initGitForPMO;
+    private logNextSteps;
+    /**
+     * Check GitHub CLI setup and provide guidance for PR workflow
+     */
+    private checkGitHubCLI;
+}