@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/gh/token.js

@@ -0,0 +1,59 @@
+import { Command } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { styles } from '../../lib/styles.js';
+import { isGHInstalled, isGHAuthenticated, isGHTokenInEnv } from '../../lib/pr/index.js';
+export default class GHToken extends Command {
+    static description = 'Show GH_TOKEN setup for devcontainer PR creation';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        // Check if gh is installed
+        if (!isGHInstalled()) {
+            this.log(chalk.red('  ✗ gh CLI not installed'));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    Install first:'));
+            this.log(chalk.cyan('      brew install gh'));
+            return;
+        }
+        // Check if gh is authenticated
+        if (!isGHAuthenticated()) {
+            this.log(chalk.yellow('  ⚠ gh CLI not authenticated'));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    Authenticate first:'));
+            this.log(chalk.cyan('      prlt gh login'));
+            return;
+        }
+        // Check if already set
+        if (isGHTokenInEnv()) {
+            this.log(chalk.green('  ✓ GH_TOKEN is already set in your environment'));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    PR creation will work in devcontainers.'));
+            return;
+        }
+        // Detect shell
+        const shell = process.env.SHELL || '/bin/zsh';
+        const rcFile = shell.includes('zsh') ? '~/.zshrc' : shell.includes('bash') ? '~/.bashrc' : '~/.profile';
+        this.log(chalk.yellow('  ⚠ GH_TOKEN not set'));
+        this.log(styles.muted(''));
+        this.log(styles.muted('    To enable PR creation from devcontainers, add this to your shell profile:'));
+        this.log(styles.muted(''));
+        this.log(chalk.cyan(`      echo 'export GH_TOKEN=$(gh auth token 2>/dev/null)' >> ${rcFile}`));
+        this.log(styles.muted(''));
+        this.log(styles.muted('    Then restart your terminal or run:'));
+        this.log(chalk.cyan(`      source ${rcFile}`));
+        this.log(styles.muted(''));
+        // Show current token (masked) for verification
+        try {
+            const token = execSync('gh auth token', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            if (token) {
+                const masked = token.substring(0, 4) + '...' + token.substring(token.length - 4);
+                this.log(styles.muted(`    Your current gh token: ${masked}`));
+            }
+        }
+        catch {
+            // Ignore - token retrieval might fail
+        }
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,26 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        agents: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        repos: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        pmo: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Human mode: interactive prompts with colored output
+     */
+    private runHumanMode;
+    /**
+     * Agent mode: use flags, output JSON
+     */
+    private runAgentMode;
+    /**
+     * Output JSON to stdout
+     */
+    private outputJson;
+}

package/dist/commands/init.js

@@ -0,0 +1,200 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { promptForHQName, promptForHQLocation, initializeHQ, showNextSteps, validateHQLocation } from '../lib/init/index.js';
+import { promptForAgentsWithTheme } from '../lib/agents/index.js';
+import { promptForRepositories } from '../lib/repos/index.js';
+import { promptForPMOSetup } from '../lib/pmo/index.js';
+export default class Init extends Command {
+    static description = 'Initialize an HQ (headquarters) for managing repositories, agents, and projects';
+    static examples = [
+        // Human mode (interactive)
+        '<%= config.bin %> <%= command.id %>',
+        // Agent mode (JSON)
+        '<%= config.bin %> <%= command.id %> --json --name myproject',
+        '<%= config.bin %> <%= command.id %> --json --name myproject --path /path/to/hq --agents agent1,agent2 --pmo',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'Agent mode: use flags instead of prompts, output JSON',
+            default: false,
+        }),
+        name: Flags.string({
+            description: 'HQ name (required in --json mode)',
+            char: 'n',
+        }),
+        path: Flags.string({
+            description: 'HQ path (defaults to ./{name}-hq)',
+            char: 'p',
+        }),
+        agents: Flags.string({
+            description: 'Comma-separated list of agent names',
+            char: 'a',
+        }),
+        repos: Flags.string({
+            description: 'Comma-separated list of repository paths to clone/move',
+            char: 'r',
+        }),
+        pmo: Flags.boolean({
+            description: 'Include PMO (Project Management Office)',
+            default: true,
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        if (flags.json) {
+            await this.runAgentMode(flags);
+        }
+        else if (!process.stdin.isTTY) {
+            // Non-interactive environment (likely an AI agent)
+            // Output guidance as JSON
+            this.outputJson({
+                success: false,
+                error: 'Interactive mode requires a TTY. Use --json flag for agent mode.',
+                hint: 'Run: prlt init --json --name <hq-name> [--path <path>] [--agents a1,a2] [--no-pmo]',
+                flags: {
+                    '--json': 'Enable agent mode with JSON output',
+                    '--name, -n': 'HQ name (required)',
+                    '--path, -p': 'HQ path (defaults to ./{name}-hq)',
+                    '--agents, -a': 'Comma-separated agent names',
+                    '--repos, -r': 'Comma-separated repo paths',
+                    '--pmo/--no-pmo': 'Include PMO (default: true)',
+                },
+            });
+            this.exit(1);
+        }
+        else {
+            await this.runHumanMode();
+        }
+    }
+    /**
+     * Human mode: interactive prompts with colored output
+     */
+    async runHumanMode() {
+        console.log(chalk.blue('🚀 Welcome to Proletariat...\n'));
+        console.log(chalk.blue('🏢 Setting up your headquarters...\n'));
+        // Step 1: Get HQ name
+        const hqName = await promptForHQName();
+        // Step 2: Determine location (always adds -hq suffix)
+        const hqPath = await promptForHQLocation(hqName);
+        // Step 3: Add agents (with theme options)
+        const agentResult = await promptForAgentsWithTheme();
+        // Step 4: Add repositories
+        const repos = await promptForRepositories(process.cwd(), []);
+        // Step 5: PMO setup (uses shared prompt from lib/pmo)
+        const pmoSetup = await promptForPMOSetup(hqPath, hqName);
+        // Create the options object
+        const options = {
+            workspaceType: 'hq',
+            hqName,
+            hqPath,
+            selectedAgents: agentResult.agents,
+            repos,
+            pmoSetup,
+            themeId: agentResult.themeId,
+            customTheme: agentResult.customTheme,
+        };
+        // Initialize the HQ
+        await initializeHQ(options);
+        // Show next steps
+        await showNextSteps(options);
+    }
+    /**
+     * Agent mode: use flags, output JSON
+     */
+    async runAgentMode(flags) {
+        // Validate required fields
+        if (!flags.name) {
+            this.outputJson({
+                success: false,
+                error: 'Missing required flag: --name',
+            });
+            this.exit(1);
+        }
+        const hqName = flags.name;
+        const hqPath = flags.path || path.resolve(`./${hqName}-hq`);
+        // Validate HQ path is not inside a git repo
+        if (!validateHQLocation(hqPath)) {
+            this.outputJson({
+                success: false,
+                error: 'Cannot create HQ inside a git repository',
+                path: hqPath,
+            });
+            this.exit(1);
+        }
+        // Check if directory already exists
+        if (fs.existsSync(hqPath)) {
+            this.outputJson({
+                success: false,
+                error: 'Directory already exists',
+                path: hqPath,
+            });
+            this.exit(1);
+        }
+        // Parse agents
+        const selectedAgents = flags.agents
+            ? flags.agents.split(',').map(a => a.trim()).filter(Boolean)
+            : [];
+        // Parse repos
+        const repos = flags.repos
+            ? flags.repos.split(',').map(r => ({
+                path: r.trim(),
+                action: 'clone',
+            })).filter(r => r.path)
+            : [];
+        // Create options
+        const options = {
+            workspaceType: 'hq',
+            hqName,
+            hqPath,
+            selectedAgents,
+            repos,
+            quiet: true, // Suppress console output in JSON mode
+            pmoSetup: {
+                includePMO: flags.pmo,
+                location: 'separate',
+                boardTemplate: 'default',
+                boardName: `${hqName}-kanban`,
+                columns: ['Backlog', 'In Progress', 'Review', 'Done'],
+                storageType: 'sqlite',
+            },
+        };
+        try {
+            // Suppress console output in JSON mode
+            const originalLog = console.log;
+            console.log = () => { };
+            // Initialize the HQ
+            await initializeHQ(options);
+            // Restore console.log
+            console.log = originalLog;
+            // Output success JSON
+            this.outputJson({
+                success: true,
+                hq: {
+                    name: hqName,
+                    path: hqPath,
+                    agents: selectedAgents,
+                    repos: repos.map(r => r.path),
+                    pmo: flags.pmo,
+                },
+            });
+        }
+        catch (error) {
+            // Restore console.log on error
+            console.log = console.log;
+            this.outputJson({
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+            this.exit(1);
+        }
+    }
+    /**
+     * Output JSON to stdout
+     */
+    outputJson(data) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+}

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

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

package/dist/commands/phase/create.js

@@ -0,0 +1,123 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { STATE_CATEGORY_ORDER } from '../../lib/pmo/types.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class PhaseCreate extends PMOCommand {
+    static description = 'Create a new project lifecycle phase';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "On Hold" --category unstarted',
+        '<%= config.bin %> <%= command.id %> "In Review" --category started --color "#FFA500"',
+        '<%= config.bin %> <%= command.id %> -i  # Interactive mode',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Phase name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        category: Flags.string({
+            char: 'c',
+            description: 'State category',
+            options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
+        }),
+        color: Flags.string({
+            description: 'Hex color (e.g., "#FF5733")',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Phase description',
+        }),
+        default: Flags.boolean({
+            description: 'Set as default phase for new projects',
+            default: false,
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(PhaseCreate);
+        {
+            let phaseData;
+            // Auto-enter interactive mode if any required value is missing
+            if (flags.interactive || !args.name || !flags.category) {
+                // Check if JSON output mode is active
+                const jsonMode = shouldOutputJson(flags);
+                // In JSON mode, output form prompt
+                // Define labels 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: 'Phase name:', default: args.name },
+                    { type: 'list', name: 'category', message: 'Category:', choices: categoryChoices, default: flags.category },
+                    { type: 'input', name: 'color', message: 'Color (hex, optional):', default: flags.color },
+                    { type: 'input', name: 'description', message: 'Description (optional):', default: flags.description },
+                    { type: 'confirm', name: 'isDefault', message: 'Set as default for new projects?', default: flags.default || false },
+                ];
+                if (jsonMode) {
+                    outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('phase create', flags));
+                }
+                phaseData = await this.promptPhaseData(fields);
+            }
+            else {
+                phaseData = {
+                    name: args.name,
+                    category: flags.category,
+                    color: flags.color,
+                    description: flags.description,
+                    isDefault: flags.default,
+                };
+            }
+            const phase = await this.storage.createPhase(phaseData);
+            this.log(styles.success(`\nCreated 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 promptPhaseData(fields) {
+        // Build inquirer prompts from fields, adding validators
+        const answers = await inquirer.prompt(fields.map(field => ({
+            ...field,
+            validate: field.name === 'name'
+                ? ((input) => input.length > 0 || 'Name is required')
+                : undefined,
+        })));
+        return {
+            name: answers.name,
+            category: answers.category,
+            color: answers.color || undefined,
+            description: answers.description || undefined,
+            isDefault: answers.isDefault,
+        };
+    }
+}

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

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

@@ -0,0 +1,73 @@
+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 PhaseDelete extends PMOCommand {
+    static description = 'Delete a project lifecycle phase';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> on-hold',
+        '<%= config.bin %> <%= command.id %> on-hold --force',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Phase ID',
+            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(PhaseDelete);
+        // 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 delete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const phase = await this.storage.getPhase(args.id);
+        if (!phase) {
+            return handleError('PHASE_NOT_FOUND', `Phase "${args.id}" not found.`);
+        }
+        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 "${phase.name}"?`, confirmChoices), createMetadata('phase delete', flags));
+                return;
+            }
+            const { confirm } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Delete phase "${phase.name}"?`,
+                    default: false,
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        await this.storage.deletePhase(args.id);
+        this.log(styles.success(`\nDeleted phase "${phase.name}"`));
+    }
+}

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

@@ -0,0 +1,12 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class PhaseList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        category: 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 groupByCategory;
+}

package/dist/commands/phase/list.js

@@ -0,0 +1,76 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { STATE_CATEGORY_ORDER } from '../../lib/pmo/types.js';
+export default class PhaseList extends PMOCommand {
+    static description = 'List all project lifecycle phases';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --category started',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        category: Flags.string({
+            char: 'c',
+            description: 'Filter by category',
+            options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(PhaseList);
+        const phases = await this.storage.listPhases(flags.category ? { category: flags.category } : undefined);
+        if (flags.json) {
+            this.log(JSON.stringify(phases, null, 2));
+            return;
+        }
+        if (phases.length === 0) {
+            this.log(styles.muted('\nNo phases found.'));
+            return;
+        }
+        // Group by category
+        const grouped = this.groupByCategory(phases);
+        this.log(`\n📊 ${styles.emphasis('Project Lifecycle Phases')}`);
+        this.log('═'.repeat(60));
+        const categoryEmoji = {
+            triage: '📬',
+            backlog: '📥',
+            unstarted: '📋',
+            started: '🚀',
+            completed: '✅',
+            canceled: '🚫',
+        };
+        for (const category of STATE_CATEGORY_ORDER) {
+            if (flags.category && flags.category !== category)
+                continue;
+            const categoryPhases = grouped.get(category);
+            if (!categoryPhases || categoryPhases.length === 0)
+                continue;
+            const emoji = categoryEmoji[category];
+            this.log(`\n${emoji} ${styles.emphasis(category.toUpperCase())}`);
+            this.log('─'.repeat(40));
+            for (const phase of categoryPhases) {
+                const defaultBadge = phase.isDefault ? styles.muted(' (default)') : '';
+                const colorPreview = phase.color ? `[${phase.color}]` : '';
+                this.log(`  ${phase.name}${defaultBadge} ${styles.muted(colorPreview)}`);
+                if (phase.description) {
+                    this.log(`    ${styles.muted(phase.description)}`);
+                }
+            }
+        }
+        this.log('');
+    }
+    groupByCategory(phases) {
+        const grouped = new Map();
+        for (const phase of phases) {
+            const existing = grouped.get(phase.category) || [];
+            existing.push(phase);
+            grouped.set(phase.category, existing);
+        }
+        return grouped;
+    }
+}

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

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