@proletariat/cli 0.1.4 → 0.3.0

package/dist/commands/phase/move.js

@@ -0,0 +1,115 @@
+import { Args, Flags } 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 PhaseMove extends PMOCommand {
+    static description = 'Change the position of a phase within its category';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> on-hold --position 0',
+        '<%= config.bin %> <%= command.id %> in-review --position 1',
+        '<%= 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,
+        position: Flags.integer({
+            char: 'p',
+            description: 'New position (0-indexed)',
+            required: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(PhaseMove);
+        // 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 move', 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}, position ${p.position})`,
+                    value: p.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'phaseId', 'Select phase to move:', phaseChoices), createMetadata('phase move', flags));
+                return;
+            }
+            const { selectedId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedId',
+                    message: 'Select phase to move:',
+                    choices: phases.map(p => ({
+                        name: `${p.name} (${p.category}, position ${p.position})`,
+                        value: p.id,
+                    })),
+                }]);
+            phaseId = selectedId;
+        }
+        const phase = await this.storage.getPhase(phaseId);
+        if (!phase) {
+            return handleError('PHASE_NOT_FOUND', `Phase "${phaseId}" not found.`);
+        }
+        // Get position - prompt if not provided
+        let newPosition = flags.position;
+        if (newPosition === undefined) {
+            // Get phases in the same category to show valid positions
+            const phases = await this.storage.listPhases();
+            const categoryPhases = phases.filter(p => p.category === phase.category);
+            // In JSON mode, output position selection prompt
+            if (jsonMode) {
+                const positionChoices = categoryPhases.map((_, idx) => ({
+                    name: `Position ${idx}${idx === phase.position ? ' (current)' : ''}`,
+                    value: String(idx),
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'position', `New position within ${phase.category} (currently ${phase.position}):`, positionChoices), createMetadata('phase move', flags));
+                return;
+            }
+            const { position } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'position',
+                    message: `New position within ${phase.category} (currently ${phase.position}):`,
+                    choices: categoryPhases.map((_, idx) => ({
+                        name: `Position ${idx}${idx === phase.position ? ' (current)' : ''}`,
+                        value: idx,
+                    })),
+                    default: phase.position,
+                }]);
+            newPosition = position;
+        }
+        if (newPosition < 0) {
+            this.error('Position must be >= 0');
+        }
+        const updated = await this.storage.reorderPhase(phaseId, newPosition);
+        if (phase.position === updated.position) {
+            this.log(styles.muted(`Phase "${updated.name}" is already at position ${updated.position}`));
+        }
+        else {
+            this.log(styles.success(`\nMoved phase "${updated.name}" from position ${phase.position} to ${updated.position}`));
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class PhaseTemplateApply extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        template: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        force: 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>;
+}

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

@@ -0,0 +1,106 @@
+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 PhaseTemplateApply extends PMOCommand {
+    static description = 'Apply a phase template to the workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> default',
+        '<%= config.bin %> <%= command.id %> agile',
+        '<%= config.bin %> <%= command.id %> product --force  # Skip confirmation',
+    ];
+    static args = {
+        template: Args.string({
+            description: 'Phase template ID to apply',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt (will replace existing phases)',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(PhaseTemplateApply);
+        // 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 template apply', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get template - prompt for selection if not provided
+        let templateId = args.template;
+        if (!templateId) {
+            const templates = await this.storage.listPhaseTemplates();
+            if (templates.length === 0) {
+                return handleError('NO_TEMPLATES', `No phase templates found.\nCreate one with: prlt phase template create "Template Name"`);
+            }
+            const { selectedTemplate } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedTemplate',
+                    message: 'Select a phase template:',
+                    choices: templates.map(t => ({
+                        name: `${t.name}${t.description ? ` - ${t.description}` : ''}`,
+                        value: t.id,
+                    })),
+                }]);
+            templateId = selectedTemplate;
+        }
+        // Verify template exists
+        const template = await this.storage.getPhaseTemplate(templateId);
+        if (!template) {
+            return handleError('TEMPLATE_NOT_FOUND', `Phase template not found: ${templateId}. Run 'prlt phase template list' to see available templates.`);
+        }
+        // Check if workspace has existing phases
+        const existingPhases = await this.storage.listPhases();
+        if (existingPhases.length > 0 && !flags.force) {
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                const confirmChoices = [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ];
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', `Workspace has ${existingPhases.length} existing phase(s). Applying will REPLACE all. Apply template "${template.name}"?`, confirmChoices), createMetadata('phase template apply', flags));
+                return;
+            }
+            this.log(styles.warning(`\nWorkspace has ${existingPhases.length} existing phase(s).`));
+            this.log(styles.warning('Applying a template will REPLACE all existing phases.'));
+            this.log('');
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Apply template "${template.name}" and replace existing phases?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled'));
+                return;
+            }
+        }
+        // Apply template
+        const phases = await this.storage.applyPhaseTemplate(templateId);
+        this.log(styles.success(`\nApplied phase template "${styles.emphasis(template.name)}"`));
+        this.log(styles.muted(`Created ${phases.length} phases:`));
+        for (const phase of phases) {
+            const defaultBadge = phase.isDefault ? ' (default)' : '';
+            this.log(styles.muted(`  • ${phase.name} [${phase.category}]${defaultBadge}`));
+        }
+    }
+}

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

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

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

@@ -0,0 +1,58 @@
+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 PhaseTemplateCreate extends PMOCommand {
+    static description = 'Create a new phase template from current workspace phases';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "My Custom Phases"',
+        '<%= config.bin %> <%= command.id %> "Enterprise" --description "Enterprise project lifecycle"',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Name for the new template',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(PhaseTemplateCreate);
+        // Get template name - prompt if not provided
+        let templateName = args.name;
+        if (!templateName) {
+            const { name } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'name',
+                    message: 'Template name:',
+                    validate: (input) => input.length > 0 || 'Name is required',
+                }]);
+            templateName = name;
+        }
+        // Get description if not provided
+        let description = flags.description;
+        if (description === undefined) {
+            const { desc } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'desc',
+                    message: 'Description (optional):',
+                }]);
+            description = desc || undefined;
+        }
+        const template = await this.storage.savePhaseTemplate(templateName, description);
+        this.log(styles.success(`\nCreated phase template "${styles.emphasis(template.name)}" (${template.id})`));
+        this.log(styles.muted(`Saved ${template.phases.length} phases:`));
+        for (const phase of template.phases) {
+            const defaultBadge = phase.isDefault ? ' (default)' : '';
+            this.log(styles.muted(`  • ${phase.name} [${phase.category}]${defaultBadge}`));
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class PhaseTemplateDelete extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        force: 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>;
+}

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

@@ -0,0 +1,98 @@
+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 PhaseTemplateDelete extends PMOCommand {
+    static description = 'Delete a phase template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-custom-template',
+        '<%= config.bin %> <%= command.id %> my-template --force',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Template ID to delete',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(PhaseTemplateDelete);
+        // 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 template delete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get template - prompt for selection if not provided
+        let templateId = args.id;
+        if (!templateId) {
+            const templates = await this.storage.listPhaseTemplates();
+            const deletableTemplates = templates.filter(t => !t.isBuiltin);
+            if (deletableTemplates.length === 0) {
+                return handleError('NO_TEMPLATES', `No deletable phase templates found (built-in templates cannot be deleted).`);
+            }
+            const { selectedTemplate } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedTemplate',
+                    message: 'Select a template to delete:',
+                    choices: deletableTemplates.map(t => ({
+                        name: `${t.name}${t.description ? ` - ${t.description}` : ''}`,
+                        value: t.id,
+                    })),
+                }]);
+            templateId = selectedTemplate;
+        }
+        // Verify template exists
+        const template = await this.storage.getPhaseTemplate(templateId);
+        if (!template) {
+            return handleError('TEMPLATE_NOT_FOUND', `Phase template not found: ${templateId}`);
+        }
+        if (template.isBuiltin) {
+            return handleError('CANNOT_DELETE_BUILTIN', 'Cannot delete built-in templates');
+        }
+        if (!flags.force) {
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                const confirmChoices = [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ];
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', `Delete phase template "${template.name}"?`, confirmChoices), createMetadata('phase template delete', flags));
+                return;
+            }
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Delete phase template "${template.name}"?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled'));
+                return;
+            }
+        }
+        await this.storage.deletePhaseTemplate(templateId);
+        this.log(styles.success(`\nDeleted phase template "${template.name}"`));
+    }
+}

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

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

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

@@ -0,0 +1,128 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class PhaseTemplateMenu extends PMOCommand {
+    static description = 'Interactive menu for project phase template operations';
+    static aliases = ['phase:templates'];
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(PhaseTemplateMenu);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        const menuChoices = [
+            { name: 'List available templates', value: 'list' },
+            { name: 'Apply template to workspace', value: 'apply' },
+            { name: 'Save current phases as template', value: 'create' },
+            { name: 'Update template', value: 'update' },
+            { name: 'Delete template', value: 'delete' },
+            { name: 'Cancel', value: 'cancel' },
+        ];
+        const message = 'Phase Templates - What would you like to do?';
+        // In JSON mode, output menu prompt
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, menuChoices), createMetadata('phase template', flags));
+            return;
+        }
+        {
+            // Show interactive menu
+            const { action } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'action',
+                    message: '📊 ' + message,
+                    choices: [
+                        ...menuChoices.slice(0, 3),
+                        new inquirer.Separator('──────────────'),
+                        ...menuChoices.slice(3),
+                    ],
+                }]);
+            if (action === 'cancel') {
+                return;
+            }
+            // Run the selected subcommand
+            switch (action) {
+                case 'list':
+                    await this.config.runCommand('phase:template:list', []);
+                    break;
+                case 'apply': {
+                    const templateId = await this.selectTemplate(this.storage, 'Select template to apply:');
+                    if (templateId) {
+                        await this.config.runCommand('phase:template:apply', [templateId]);
+                    }
+                    break;
+                }
+                case 'create': {
+                    const { name } = await inquirer.prompt([{
+                            type: 'input',
+                            name: 'name',
+                            message: 'Template name:',
+                            validate: (input) => input.length > 0 || 'Name is required',
+                        }]);
+                    await this.config.runCommand('phase:template:create', [name]);
+                    break;
+                }
+                case 'update': {
+                    const customTemplates = (await this.storage.listPhaseTemplates()).filter(t => !t.isBuiltin);
+                    if (customTemplates.length === 0) {
+                        this.log('No custom templates to update. Built-in templates cannot be modified.');
+                        return;
+                    }
+                    const templateId = await this.selectTemplate(this.storage, 'Select template to update:', true);
+                    if (templateId) {
+                        await this.config.runCommand('phase:template:update', [templateId]);
+                    }
+                    break;
+                }
+                case 'delete': {
+                    const customTemplates = (await this.storage.listPhaseTemplates()).filter(t => !t.isBuiltin);
+                    if (customTemplates.length === 0) {
+                        this.log('No custom templates to delete. Built-in templates cannot be deleted.');
+                        return;
+                    }
+                    const templateId = await this.selectTemplate(this.storage, 'Select template to delete:', true);
+                    if (templateId) {
+                        await this.config.runCommand('phase:template:delete', [templateId]);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    async selectTemplate(storage, message, customOnly = false) {
+        let templates = await storage.listPhaseTemplates();
+        if (customOnly) {
+            templates = templates.filter(t => !t.isBuiltin);
+        }
+        if (templates.length === 0) {
+            this.log('No templates found.');
+            return null;
+        }
+        const { selected } = await inquirer.prompt([{
+                type: 'list',
+                name: 'selected',
+                message,
+                choices: [
+                    ...templates.map(t => ({
+                        name: `${t.name} (${t.id})${t.isBuiltin ? '' : ' [custom]'}`,
+                        value: t.id,
+                    })),
+                    new inquirer.Separator(),
+                    { name: 'Cancel', value: null },
+                ],
+            }]);
+        return selected;
+    }
+}

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

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