@proletariat/cli 0.2.0 → 0.3.0

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import {execute} from '@oclif/core'
+
+// Handle process termination gracefully
+process.on('SIGINT', () => {
+  console.log('\n'); // Add newline for clean exit
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  process.exit(0);
+});
+
+try {
+  await execute({dir: import.meta.url});
+} catch (error) {
+  // Handle any unhandled errors
+  if (error.code !== 'EEXIT') {
+    console.error(error);
+    process.exit(1);
+  }
+}

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

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

@@ -0,0 +1,126 @@
+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, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class ActionCreate extends PMOCommand {
+    static description = 'Create a new work action';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "Security Review" --prompt "Review for vulnerabilities..."',
+        '<%= config.bin %> <%= command.id %> "Write Docs" --prompt "Document this feature..." --suggested-for completed',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Name for the new action',
+            required: false, // Not required - will prompt if missing
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        prompt: Flags.string({
+            char: 'p',
+            description: 'The prompt to send to the agent',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Short description of what this action does',
+        }),
+        '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(ActionCreate);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        let name = args.name;
+        let prompt = flags.prompt;
+        let description = flags.description;
+        let suggestedFor;
+        let moveTo = flags['move-to'];
+        // Interactive mode if name or prompt is missing
+        if (!name || !prompt || flags.interactive) {
+            // Build choices once, use for both JSON and interactive modes
+            const suggestedForChoices = STATE_CATEGORY_ORDER.map(c => ({ name: c, value: c }));
+            const moveToChoices = [
+                { name: '(no automatic move)', value: '' },
+                ...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: 'Action name:', default: name },
+                { type: 'input', name: 'description', message: 'Description (optional):', default: description || '' },
+                { type: 'editor', name: 'prompt', message: 'Prompt (opens editor):', default: prompt || 'Enter the prompt that will be sent to the agent...' },
+                { type: 'checkbox', name: 'suggestedFor', message: 'Suggested for categories (optional):', choices: suggestedForChoices },
+                { type: 'list', name: 'moveTo', message: 'Move ticket to category after action:', choices: moveToChoices, default: moveTo || '' },
+            ];
+            // In JSON mode, output form prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('action create', flags));
+            }
+            this.log('');
+            this.log(styles.header('Create Custom Action'));
+            this.log('');
+            // Build inquirer prompts from fields, adding validators and conditionals
+            const answers = await inquirer.prompt(fields.map(field => ({
+                ...field,
+                // Add validators for required fields
+                validate: field.name === 'name' ? ((input) => input.trim() ? true : 'Name is required')
+                    : field.name === 'prompt' ? ((input) => input.trim() ? true : 'Prompt is required')
+                        : undefined,
+                // Skip fields that already have values
+                when: field.name === 'name' ? !name
+                    : field.name === 'prompt' ? !prompt
+                        : true,
+            })));
+            name = answers.name || name;
+            prompt = answers.prompt || prompt;
+            description = answers.description || description;
+            suggestedFor = answers.suggestedFor?.length ? answers.suggestedFor : undefined;
+            moveTo = answers.moveTo || undefined;
+        }
+        else {
+            // Parse flags
+            suggestedFor = flags['suggested-for']
+                ? flags['suggested-for'].split(',').map(s => s.trim())
+                : undefined;
+        }
+        if (!name || !prompt) {
+            this.error('Name and prompt are required.');
+        }
+        const action = await this.storage.createAction({
+            name,
+            description,
+            prompt,
+            suggestedForCategories: suggestedFor,
+            defaultMoveToCategory: moveTo,
+        });
+        this.log(styles.success(`\nCreated action "${styles.emphasis(action.name)}" (${action.id})`));
+        if (action.description) {
+            this.log(styles.muted(`  ${action.description}`));
+        }
+        if (action.suggestedForCategories?.length) {
+            this.log(styles.muted(`  Suggested for: ${action.suggestedForCategories.join(', ')}`));
+        }
+        this.log('');
+        this.log(styles.muted(`Use with: prlt work start TKT-001 --action ${action.id}`));
+    }
+}

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

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

@@ -0,0 +1,78 @@
+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 ActionDelete extends PMOCommand {
+    static description = 'Delete a work action';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-custom-action',
+        '<%= config.bin %> <%= command.id %> my-action --force',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Action ID to delete',
+            required: true,
+        }),
+    };
+    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(ActionDelete);
+        // 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 delete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const action = await this.storage.getAction(args.id);
+        if (!action) {
+            return handleError('ACTION_NOT_FOUND', `Action not found: ${args.id}`);
+        }
+        if (action.isBuiltin) {
+            return handleError('CANNOT_DELETE_BUILTIN', 'Cannot delete built-in actions');
+        }
+        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 action "${action.name}"?`, confirmChoices), createMetadata('action delete', flags));
+                return;
+            }
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Delete action "${action.name}"?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled'));
+                return;
+            }
+        }
+        await this.storage.deleteAction(args.id);
+        this.log(styles.success(`\nDeleted action "${action.name}"`));
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Action 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 selectAction;
+}

package/dist/commands/action/index.js

@@ -0,0 +1,107 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, } from '../../lib/prompt-json.js';
+export default class Action extends PMOCommand {
+    static description = 'Interactive menu for work action operations';
+    static aliases = ['actions'];
+    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(Action);
+        // 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 actions', command: 'prlt action list --format json' },
+            { id: 'show', name: 'View action details', command: 'prlt action show --json' },
+            { id: 'create', name: 'Create custom action', command: 'prlt action create --json' },
+            { id: 'update', name: 'Update action', command: 'prlt action update --json' },
+            { id: 'delete', name: 'Delete action', command: 'prlt action delete --json' },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'Work Actions - What would you like to do?';
+        const action = await this.selectFromList({
+            message: '🎬 ' + message,
+            items: menuChoices,
+            getName: (c) => c.name,
+            getValue: (c) => c.id,
+            getCommand: (c) => c.command,
+            jsonMode: jsonMode ? { flags, commandName: 'action' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            return;
+        }
+        // Run the selected subcommand
+        switch (action) {
+            case 'list':
+                await this.config.runCommand('action:list', []);
+                break;
+            case 'show': {
+                const actionId = await this.selectAction(this.storage, 'Select action to view:');
+                if (actionId) {
+                    await this.config.runCommand('action:show', [actionId]);
+                }
+                break;
+            }
+            case 'create':
+                await this.config.runCommand('action:create', []);
+                break;
+            case 'update': {
+                const actionId = await this.selectAction(this.storage, 'Select action to update:');
+                if (actionId) {
+                    await this.config.runCommand('action:update', [actionId]);
+                }
+                break;
+            }
+            case 'delete': {
+                const customActions = (await this.storage.listActions()).filter(a => !a.isBuiltin);
+                if (customActions.length === 0) {
+                    this.log('No custom actions to delete. Built-in actions cannot be deleted.');
+                    return;
+                }
+                const actionId = await this.selectAction(this.storage, 'Select action to delete:', true);
+                if (actionId) {
+                    await this.config.runCommand('action:delete', [actionId]);
+                }
+                break;
+            }
+        }
+    }
+    async selectAction(storage, message, customOnly = false) {
+        let actions = await storage.listActions();
+        if (customOnly) {
+            actions = actions.filter(a => !a.isBuiltin);
+        }
+        if (actions.length === 0) {
+            this.log('No actions found.');
+            return null;
+        }
+        const { selected } = await inquirer.prompt([{
+                type: 'list',
+                name: 'selected',
+                message,
+                choices: [
+                    ...actions.map(a => ({
+                        name: `${a.name} (${a.id})${a.isBuiltin ? '' : ' [custom]'}`,
+                        value: a.id,
+                    })),
+                    new inquirer.Separator(),
+                    { name: 'Cancel', value: null },
+                ],
+            }]);
+        return selected;
+    }
+}

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

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

package/dist/commands/action/list.js

@@ -0,0 +1,89 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class ActionList extends PMOCommand {
+    static description = 'List available work actions';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --builtin',
+        '<%= config.bin %> <%= command.id %> --custom',
+        '<%= config.bin %> <%= command.id %> --suggested-for started',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        builtin: Flags.boolean({
+            description: 'Show only built-in actions',
+            exclusive: ['custom'],
+        }),
+        custom: Flags.boolean({
+            description: 'Show only custom actions',
+            exclusive: ['builtin'],
+        }),
+        'suggested-for': Flags.string({
+            description: 'Filter to actions suggested for a category',
+            options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(ActionList);
+        const filter = {};
+        if (flags.builtin)
+            filter.isBuiltin = true;
+        if (flags.custom)
+            filter.isBuiltin = false;
+        if (flags['suggested-for'])
+            filter.suggestedFor = flags['suggested-for'];
+        const actions = await this.storage.listActions(filter);
+        if (flags.json) {
+            this.log(JSON.stringify(actions, null, 2));
+            return;
+        }
+        if (actions.length === 0) {
+            this.log(styles.muted('\nNo actions found.'));
+            return;
+        }
+        this.log(`\n${styles.emphasis('Work Actions')}`);
+        this.log('═'.repeat(60));
+        // Group by builtin vs custom
+        const builtinActions = actions.filter(a => a.isBuiltin);
+        const customActions = actions.filter(a => !a.isBuiltin);
+        if (builtinActions.length > 0 && !flags.custom) {
+            this.log(`\n${styles.emphasis('Built-in Actions')}`);
+            this.log('─'.repeat(40));
+            for (const action of builtinActions) {
+                this.printAction(action);
+            }
+        }
+        if (customActions.length > 0 && !flags.builtin) {
+            this.log(`\n${styles.emphasis('Custom Actions')}`);
+            this.log('─'.repeat(40));
+            for (const action of customActions) {
+                this.printAction(action);
+            }
+        }
+        this.log('');
+        this.log(styles.muted('Use an action: prlt work start TKT-001 --action <id>'));
+        this.log(styles.muted('View details:  prlt action show <id>'));
+        this.log('');
+    }
+    printAction(action) {
+        this.log(`\n  ${styles.emphasis(action.name)} ${styles.muted(`(${action.id})`)}`);
+        if (action.description) {
+            this.log(`    ${styles.muted(action.description)}`);
+        }
+        const details = [];
+        if (action.suggestedForCategories?.length) {
+            details.push(`Suggested for: ${action.suggestedForCategories.join(', ')}`);
+        }
+        if (action.defaultMoveToCategory) {
+            details.push(`Moves to: ${action.defaultMoveToCategory}`);
+        }
+        if (details.length > 0) {
+            this.log(`    ${styles.muted(details.join(' | '))}`);
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ActionRun extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        ticketIds: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        action: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        category: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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>;
+    };
+    execute(): Promise<void>;
+}