@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/action/run.js

@@ -0,0 +1,179 @@
+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 ActionRun extends PMOCommand {
+    static description = 'Run an action on one or more tickets (bulk action support)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 --action implement',
+        '<%= config.bin %> <%= command.id %> TKT-001 TKT-002 TKT-003 --action groom',
+        '<%= config.bin %> <%= command.id %> --all --action groom  # All backlog tickets',
+        '<%= config.bin %> <%= command.id %> --category started --action review',
+    ];
+    static strict = false; // Allow multiple ticket IDs
+    static args = {
+        ticketIds: Args.string({
+            description: 'Ticket ID(s) to run action on',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        action: Flags.string({
+            char: 'A',
+            description: 'Action to run (e.g., groom, implement, review)',
+            required: true,
+        }),
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Run on all tickets in backlog',
+            default: false,
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'Filter tickets by status category',
+            options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
+        }),
+        'dry-run': Flags.boolean({
+            description: 'Show what would be done without executing',
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { argv, flags } = await this.parse(ActionRun);
+        const ticketIds = argv;
+        // 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('action run', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get the action
+        const action = await this.storage.getAction(flags.action);
+        if (!action) {
+            return handleError('ACTION_NOT_FOUND', `Action not found: ${flags.action}\nRun 'prlt action list' to see available actions.`);
+        }
+        // Get tickets to operate on
+        // Use -P flag to filter by project, or undefined to show all projects
+        const projectId = flags.project;
+        let tickets = [];
+        if (flags.all || flags.category) {
+            // Get tickets by filter
+            const allTickets = await this.storage.listTickets(projectId);
+            if (flags.category) {
+                tickets = allTickets.filter(t => t.statusCategory === flags.category);
+            }
+            else if (flags.all) {
+                // Default to backlog for --all
+                tickets = allTickets.filter(t => t.statusCategory === 'backlog' || !t.statusCategory);
+            }
+        }
+        else if (ticketIds.length > 0) {
+            // Get specific tickets
+            for (const id of ticketIds) {
+                const ticket = await this.storage.getTicket(id);
+                if (ticket) {
+                    tickets.push(ticket);
+                }
+                else {
+                    this.warn(`Ticket not found: ${id}`);
+                }
+            }
+        }
+        else {
+            // Interactive: show list of tickets to select
+            const allTickets = await this.storage.listTickets(projectId);
+            if (allTickets.length === 0) {
+                return handleError('NO_TICKETS', 'No tickets found.');
+            }
+            // In JSON mode, output ticket selection prompt
+            if (jsonMode) {
+                const ticketChoices = allTickets.map(t => ({
+                    name: `${t.id} - ${t.title} [${t.statusName || t.statusCategory || 'unknown'}]`,
+                    value: t.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('checkbox', 'ticketIds', `Select tickets for "${action.name}" action:`, ticketChoices), createMetadata('action run', flags));
+                return;
+            }
+            const { selectedTickets } = await inquirer.prompt([{
+                    type: 'checkbox',
+                    name: 'selectedTickets',
+                    message: `Select tickets for "${action.name}" action:`,
+                    choices: allTickets.map(t => ({
+                        name: `${t.id} - ${t.title} [${t.statusName || t.statusCategory || 'unknown'}]`,
+                        value: t.id,
+                        checked: action.suggestedForCategories?.includes(t.statusCategory),
+                    })),
+                    validate: (input) => input.length > 0 || 'Select at least one ticket',
+                }]);
+            for (const id of selectedTickets) {
+                const ticket = await this.storage.getTicket(id);
+                if (ticket)
+                    tickets.push(ticket);
+            }
+        }
+        if (tickets.length === 0) {
+            this.error('No tickets matched the criteria.');
+        }
+        // Show what will be done
+        this.log('');
+        this.log(styles.header(`🎬 Action: ${action.name}`));
+        if (action.description) {
+            this.log(styles.muted(`   ${action.description}`));
+        }
+        this.log('');
+        this.log(styles.emphasis(`Tickets (${tickets.length}):`));
+        for (const ticket of tickets) {
+            const status = ticket.statusName || ticket.statusCategory || 'unknown';
+            this.log(styles.muted(`   • ${ticket.id}: ${ticket.title} [${status}]`));
+        }
+        this.log('');
+        if (action.defaultMoveToCategory) {
+            this.log(styles.muted(`After action: tickets will move to "${action.defaultMoveToCategory}"`));
+            this.log('');
+        }
+        if (flags['dry-run']) {
+            this.log(styles.warning('DRY RUN - no changes made'));
+            return;
+        }
+        // Confirm unless --force
+        if (!flags.force && tickets.length > 1) {
+            const { confirm } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Run "${action.name}" on ${tickets.length} tickets?`,
+                    default: true,
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        // Queue the action for each ticket
+        // For now, this just outputs what would be done
+        // Full implementation would integrate with work/start
+        this.log('');
+        this.log(styles.muted('To execute, run for each ticket:'));
+        for (const ticket of tickets) {
+            this.log(styles.muted(`   prlt work start ${ticket.id} --action ${action.id}`));
+        }
+        this.log('');
+        this.log(styles.muted('Or use spawn-all to distribute to agents:'));
+        this.log(styles.muted(`   prlt work spawn-all --action ${action.id}`));
+        this.log('');
+    }
+}

package/dist/commands/action/show.d.ts

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

package/dist/commands/action/show.js

@@ -0,0 +1,47 @@
+import { Args } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class ActionShow extends PMOCommand {
+    static description = 'Show details of a work action';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> groom',
+        '<%= config.bin %> <%= command.id %> implement',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Action ID to show',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args } = await this.parse(ActionShow);
+        const action = await this.storage.getAction(args.id);
+        if (!action) {
+            this.error(`Action not found: ${args.id}`);
+        }
+        this.log(`\n${styles.emphasis(`Action: ${action.name}`)} ${styles.muted(`(${action.id})`)}`);
+        this.log('');
+        if (action.description) {
+            this.log(`${styles.muted('Description:')} ${action.description}`);
+        }
+        if (action.suggestedForCategories?.length) {
+            this.log(`${styles.muted('Suggested for:')} ${action.suggestedForCategories.join(', ')}`);
+        }
+        if (action.defaultMoveToCategory) {
+            this.log(`${styles.muted('Moves to:')} ${action.defaultMoveToCategory}`);
+        }
+        this.log(`${styles.muted('Built-in:')} ${action.isBuiltin ? 'Yes' : 'No'}`);
+        this.log('');
+        this.log(styles.muted('Prompt:'));
+        this.log('─'.repeat(40));
+        this.log(action.prompt);
+        this.log('─'.repeat(40));
+        this.log('');
+    }
+}

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

@@ -0,0 +1,22 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ActionUpdate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        prompt: 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>;
+        'suggested-for': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'move-to': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+}

package/dist/commands/action/update.js

@@ -0,0 +1,168 @@
+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 { STATE_CATEGORY_ORDER } from '../../lib/pmo/types.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class ActionUpdate extends PMOCommand {
+    static description = 'Update a work action';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-action --name "New Name"',
+        '<%= config.bin %> <%= command.id %> my-action --prompt "Updated prompt..."',
+        '<%= config.bin %> <%= command.id %> my-action  # Interactive mode',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Action ID to update',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'New action name',
+        }),
+        prompt: Flags.string({
+            char: 'p',
+            description: 'New prompt text',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'New description',
+        }),
+        'suggested-for': Flags.string({
+            description: 'Categories this action is suggested for (comma-separated)',
+        }),
+        'move-to': Flags.string({
+            description: 'Category to move ticket to after action',
+            options: ['backlog', 'unstarted', 'started', 'completed', 'canceled', ''],
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode - prompt for all fields',
+            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(ActionUpdate);
+        // 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('action update', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get current action
+        const existingAction = await this.storage.getAction(args.id);
+        if (!existingAction) {
+            return handleError('ACTION_NOT_FOUND', `Action not found: ${args.id}`);
+        }
+        if (existingAction.isBuiltin) {
+            return handleError('CANNOT_UPDATE_BUILTIN', 'Cannot update built-in actions. Create a custom action instead.');
+        }
+        const hasFlags = flags.name || flags.prompt || flags.description !== undefined ||
+            flags['suggested-for'] || flags['move-to'] !== undefined;
+        const changes = {};
+        // Interactive mode if no flags provided or --interactive flag
+        if (!hasFlags || flags.interactive) {
+            // Build choices once - single source of truth
+            const suggestedForChoices = STATE_CATEGORY_ORDER.map(c => ({ name: c, value: c }));
+            const moveToChoices = [
+                { name: '(no change)', value: '__none__' },
+                ...STATE_CATEGORY_ORDER.map(c => ({ name: c, value: c })),
+            ];
+            // Define fields once - single source of truth for both JSON and interactive modes
+            const fields = [
+                { type: 'input', name: 'name', message: 'Name:', default: existingAction.name },
+                { type: 'input', name: 'description', message: 'Description:', default: existingAction.description || '' },
+                { type: 'editor', name: 'prompt', message: 'Prompt (opens editor):', default: existingAction.prompt },
+                { type: 'checkbox', name: 'suggestedFor', message: 'Suggested for categories:', choices: suggestedForChoices, default: existingAction.suggestedForCategories || [] },
+                { type: 'list', name: 'moveTo', message: 'Move ticket to category after action:', choices: moveToChoices, default: existingAction.defaultMoveToCategory || '__none__' },
+            ];
+            // In JSON mode, output form prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('action update', flags));
+            }
+            this.log('');
+            this.log(styles.header(`Updating action: ${existingAction.name}`));
+            this.log(styles.muted('Press Enter to keep current value, or enter new value.'));
+            this.log('');
+            // Build inquirer prompts from fields, adding checkbox 'checked' state
+            const answers = await inquirer.prompt(fields.map(field => ({
+                ...field,
+                // For checkbox, convert default array to checked property on choices
+                choices: field.type === 'checkbox' && field.choices
+                    ? field.choices.map(c => ({
+                        ...c,
+                        checked: field.default?.includes(c.value),
+                    }))
+                    : field.choices,
+            })));
+            if (answers.name !== existingAction.name)
+                changes.name = answers.name;
+            if (answers.description !== (existingAction.description || ''))
+                changes.description = answers.description;
+            if (answers.prompt !== existingAction.prompt)
+                changes.prompt = answers.prompt;
+            const currentSuggested = existingAction.suggestedForCategories?.sort().join(',') || '';
+            const newSuggested = answers.suggestedFor.sort().join(',');
+            if (newSuggested !== currentSuggested) {
+                changes.suggestedForCategories = answers.suggestedFor;
+            }
+            const currentMoveTo = existingAction.defaultMoveToCategory || '__none__';
+            if (answers.moveTo !== currentMoveTo) {
+                changes.defaultMoveToCategory = answers.moveTo === '__none__' ? null : answers.moveTo;
+            }
+        }
+        else {
+            // Flag-based update
+            if (flags.name)
+                changes.name = flags.name;
+            if (flags.prompt)
+                changes.prompt = flags.prompt;
+            if (flags.description !== undefined)
+                changes.description = flags.description;
+            if (flags['suggested-for']) {
+                changes.suggestedForCategories = flags['suggested-for'].split(',').map(s => s.trim());
+            }
+            if (flags['move-to'] !== undefined) {
+                changes.defaultMoveToCategory = flags['move-to'] || null;
+            }
+        }
+        // Check if any changes
+        if (Object.keys(changes).length === 0) {
+            this.log(styles.muted('No changes made.'));
+            return;
+        }
+        // Convert null to undefined for storage layer compatibility
+        const updatePayload = {
+            ...changes,
+            defaultMoveToCategory: changes.defaultMoveToCategory === null
+                ? undefined
+                : changes.defaultMoveToCategory,
+        };
+        const action = await this.storage.updateAction(args.id, updatePayload);
+        this.log(styles.success(`\nUpdated action "${styles.emphasis(action.name)}"`));
+        if (changes.name)
+            this.log(styles.muted(`  Name: ${action.name}`));
+        if (changes.description !== undefined)
+            this.log(styles.muted(`  Description: ${action.description || '(none)'}`));
+        if (changes.prompt)
+            this.log(styles.muted(`  Prompt: (updated)`));
+        if (changes.suggestedForCategories)
+            this.log(styles.muted(`  Suggested for: ${action.suggestedForCategories?.join(', ') || '(none)'}`));
+        if (changes.defaultMoveToCategory !== undefined)
+            this.log(styles.muted(`  Moves to: ${action.defaultMoveToCategory || '(none)'}`));
+    }
+}

package/dist/commands/agent/index.d.ts

@@ -0,0 +1,13 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Agent extends PMOCommand {
+    static description: 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>;
+}

package/dist/commands/agent/index.js

@@ -0,0 +1,131 @@
+import { Flags } from '@oclif/core';
+import { colors } from '../../lib/colors.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, } from '../../lib/prompt-json.js';
+export default class Agent extends PMOCommand {
+    static description = 'Manage agents in the workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> list',
+        '<%= config.bin %> <%= command.id %> status camry',
+        '<%= config.bin %> <%= command.id %> visit tacoma',
+        '<%= config.bin %> <%= command.id %> staff add',
+        '<%= config.bin %> <%= command.id %> staff remove camry',
+        '<%= config.bin %> <%= command.id %> temp cleanup --temp',
+        '<%= config.bin %> <%= command.id %> restart altman',
+        '<%= config.bin %> <%= command.id %> rebuild altman',
+        '<%= config.bin %> <%= command.id %> shell altman',
+        '<%= config.bin %> <%= command.id %> themes list',
+    ];
+    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(Agent);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        // Each choice includes the full command for AI agents to execute
+        const menuChoices = [
+            { id: 'list', name: 'List all agents', command: 'prlt agent list --format json' },
+            { id: 'status', name: 'Show status', command: 'prlt agent status --json' },
+            { id: 'visit', name: 'Visit directory', command: 'prlt agent visit --json' },
+            { id: 'staff', name: 'Manage staff agents', command: 'prlt agent staff --json' },
+            { id: 'temp', name: 'Manage temp agents', command: 'prlt agent temp --json' },
+            { id: 'themes', name: 'Manage themes', command: 'prlt agent themes --json' },
+            { id: 'shell', name: 'Open shell', command: 'prlt agent shell --json' },
+            { id: 'restart', name: 'Restart', command: 'prlt agent restart --json' },
+            { id: 'rebuild', name: 'Rebuild', command: 'prlt agent rebuild --json' },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'What would you like to do?';
+        this.log(colors.primary('🤖 Agent Management'));
+        this.log('');
+        this.log(colors.textMuted('Note: Agent pre-registration is no longer required!'));
+        this.log(colors.textMuted('Use "prlt work spawn" to create ephemeral agents automatically.'));
+        this.log('');
+        const action = await this.selectFromList({
+            message,
+            items: menuChoices,
+            getName: (c) => c.name,
+            getValue: (c) => c.id,
+            getCommand: (c) => c.command,
+            jsonMode: jsonMode ? { flags, commandName: 'agent' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            this.log(colors.textMuted('Operation cancelled.'));
+            return;
+        }
+        // Execute the selected command directly (no subprocess)
+        try {
+            this.log(colors.primary(`\nExecuting: agent ${action}`));
+            switch (action) {
+                case 'list': {
+                    const { default: ListCommand } = await import('./list.js');
+                    const cmd = new ListCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                case 'status': {
+                    const { default: StatusCommand } = await import('./status.js');
+                    const cmd = new StatusCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                case 'visit': {
+                    const { default: VisitCommand } = await import('./visit.js');
+                    const cmd = new VisitCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                case 'staff': {
+                    const { default: StaffCommand } = await import('./staff/index.js');
+                    const cmd = new StaffCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                case 'temp': {
+                    const { default: TempCommand } = await import('./temp/index.js');
+                    const cmd = new TempCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                case 'themes': {
+                    const { default: ThemesCommand } = await import('./themes/index.js');
+                    const cmd = new ThemesCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                case 'restart': {
+                    const { default: RestartCommand } = await import('./restart.js');
+                    const cmd = new RestartCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                case 'rebuild': {
+                    const { default: RebuildCommand } = await import('./rebuild.js');
+                    const cmd = new RebuildCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                case 'shell': {
+                    const { default: ShellCommand } = await import('./shell.js');
+                    const cmd = new ShellCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                default:
+                    this.error(`Unknown action: ${action}`);
+            }
+        }
+        catch (error) {
+            this.error(`Failed to execute agent ${action}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/commands/agent/list.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@oclif/core';
+export default class List extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}