@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/execution/logs.d.ts

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

package/dist/commands/execution/logs.js

@@ -0,0 +1,161 @@
+import { Args, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+import inquirer from 'inquirer';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/storage.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class ExecutionLogs extends PMOCommand {
+    static description = 'View execution logs';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> WORK-001',
+        '<%= config.bin %> <%= command.id %> WORK-001 --follow',
+        '<%= config.bin %> <%= command.id %> WORK-001 --tail 50',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Execution ID - prompts if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        follow: Flags.boolean({
+            char: 'f',
+            description: 'Stream logs in real-time',
+            default: false,
+        }),
+        tail: Flags.integer({
+            char: 'n',
+            description: 'Show last n lines',
+        }),
+        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(ExecutionLogs);
+        // Get workspace info
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            this.error('Not in a workspace. Run "prlt init" first.');
+        }
+        // Open database
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        const db = new Database(dbPath);
+        const executionStorage = new ExecutionStorage(db);
+        try {
+            // Get execution ID - prompt if not provided
+            let execId = args.id;
+            if (!execId) {
+                const executions = executionStorage.listExecutions({ limit: 20 });
+                // Check if JSON output mode is active
+                const jsonMode = shouldOutputJson(flags);
+                if (executions.length === 0) {
+                    if (jsonMode) {
+                        outputErrorAsJson('NO_EXECUTIONS', 'No executions found.', createMetadata('execution logs', flags));
+                        db.close();
+                        this.exit(1);
+                    }
+                    this.error('No executions found.');
+                }
+                // In JSON mode, output execution selection prompt
+                if (jsonMode) {
+                    const execChoices = executions.map((e) => ({
+                        name: `${e.id} - ${e.ticketId} (${e.agentName}, ${e.status})`,
+                        value: e.id,
+                    }));
+                    outputPromptAsJson(buildPromptConfig('list', 'executionId', 'Select execution to view logs:', execChoices), createMetadata('execution logs', flags));
+                    db.close();
+                    return;
+                }
+                const { selectedId } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'selectedId',
+                        message: 'Select execution to view logs:',
+                        choices: executions.map((e) => ({
+                            name: `${e.id} - ${e.ticketId} (${e.agentName}, ${e.status})`,
+                            value: e.id,
+                        })),
+                    },
+                ]);
+                execId = selectedId;
+            }
+            // Get execution
+            const execution = executionStorage.getExecution(execId);
+            if (!execution) {
+                this.error(`Execution "${execId}" not found.`);
+            }
+            // Check for log file
+            if (!execution.logPath) {
+                this.log(styles.muted(`\nNo log file for execution ${execId}`));
+                this.log(styles.muted(`Environment: ${execution.environment}`));
+                if (execution.sessionId) {
+                    this.log('');
+                    this.log(styles.muted('View in tmux:'));
+                    this.log(styles.muted(`  tmux attach -t ${execution.sessionId}`));
+                }
+                else if (execution.environment === 'docker' && execution.containerId) {
+                    this.log('');
+                    this.log(styles.muted('View docker logs:'));
+                    this.log(styles.muted(`  docker logs -f ${execution.containerId}`));
+                }
+                this.log('');
+                return;
+            }
+            // Check if log file exists
+            if (!fs.existsSync(execution.logPath)) {
+                this.error(`Log file not found: ${execution.logPath}`);
+            }
+            // Display logs
+            this.log('');
+            this.log(styles.header(`📜 Logs for ${execution.id} (${execution.ticketId})`));
+            this.log(styles.muted(`   Log file: ${execution.logPath}`));
+            this.log('');
+            if (flags.follow) {
+                // Stream logs with tail -f
+                const tailProcess = spawn('tail', ['-f', execution.logPath], {
+                    stdio: 'inherit',
+                });
+                // Handle Ctrl+C
+                process.on('SIGINT', () => {
+                    tailProcess.kill();
+                    process.exit(0);
+                });
+                await new Promise((resolve) => {
+                    tailProcess.on('close', resolve);
+                });
+            }
+            else if (flags.tail) {
+                // Show last n lines
+                const tailProcess = spawn('tail', ['-n', flags.tail.toString(), execution.logPath], {
+                    stdio: 'inherit',
+                });
+                await new Promise((resolve) => {
+                    tailProcess.on('close', resolve);
+                });
+            }
+            else {
+                // Show entire file
+                const content = fs.readFileSync(execution.logPath, 'utf-8');
+                this.log(content);
+            }
+        }
+        finally {
+            db.close();
+        }
+    }
+}

package/dist/commands/execution/stop.d.ts

@@ -0,0 +1,22 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ExecutionStop 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>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        agent: 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>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private bulkStop;
+    private singleStop;
+    private stopExecution;
+}

package/dist/commands/execution/stop.js

@@ -0,0 +1,248 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+import inquirer from 'inquirer';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/storage.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class ExecutionStop extends PMOCommand {
+    static description = 'Stop running execution(s)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> WORK-001',
+        '<%= config.bin %> <%= command.id %> WORK-001 --force',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --all --force',
+        '<%= config.bin %> <%= command.id %> --agent altman',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Execution ID - prompts if not provided (ignored if --all or --agent used)',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Force kill (SIGKILL instead of SIGTERM)',
+            default: false,
+        }),
+        all: Flags.boolean({
+            description: 'Stop all running executions',
+            default: false,
+        }),
+        agent: Flags.string({
+            char: 'a',
+            description: 'Stop all executions for a specific agent',
+        }),
+        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(ExecutionStop);
+        // Get workspace info
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            this.error('Not in a workspace. Run "prlt init" first.');
+        }
+        // Open database
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        const db = new Database(dbPath);
+        const executionStorage = new ExecutionStorage(db);
+        try {
+            // Determine if bulk stop or single stop
+            if (flags.all || flags.agent) {
+                await this.bulkStop(executionStorage, flags);
+            }
+            else {
+                await this.singleStop(executionStorage, args.id, flags);
+            }
+        }
+        finally {
+            db.close();
+        }
+    }
+    async bulkStop(executionStorage, flags) {
+        // Get running executions
+        const runningExecutions = executionStorage.listExecutions({
+            status: 'running',
+            agentName: flags.agent,
+            limit: 100,
+        });
+        const startingExecutions = executionStorage.listExecutions({
+            status: 'starting',
+            agentName: flags.agent,
+            limit: 100,
+        });
+        const activeExecutions = [...runningExecutions, ...startingExecutions];
+        if (activeExecutions.length === 0) {
+            const scope = flags.agent ? ` for agent "${flags.agent}"` : '';
+            this.log(styles.muted(`\nNo running executions found${scope}.\n`));
+            return;
+        }
+        this.log('');
+        this.log(styles.header(`Stopping ${activeExecutions.length} execution(s)...`));
+        this.log('');
+        let stopped = 0;
+        let failed = 0;
+        for (const execution of activeExecutions) {
+            try {
+                const success = await this.stopExecution(execution, flags.force || false);
+                if (success) {
+                    executionStorage.updateStatus(execution.id, 'stopped');
+                    this.log(styles.success(`   ✓ ${execution.id} (${execution.agentName} → ${execution.ticketId})`));
+                    stopped++;
+                }
+            }
+            catch (error) {
+                this.log(styles.error(`   ✗ ${execution.id}: ${error instanceof Error ? error.message : error}`));
+                failed++;
+            }
+        }
+        this.log('');
+        this.log(styles.header('Summary'));
+        this.log(styles.success(`   Stopped: ${stopped}`));
+        if (failed > 0) {
+            this.log(styles.error(`   Failed: ${failed}`));
+        }
+        this.log('');
+    }
+    async singleStop(executionStorage, execId, flags) {
+        // Get execution ID - prompt if not provided
+        let id = execId;
+        if (!id) {
+            const runningExecutions = executionStorage.listExecutions({
+                status: 'running',
+                limit: 50,
+            });
+            // Also include 'starting' status
+            const startingExecutions = executionStorage.listExecutions({
+                status: 'starting',
+                limit: 50,
+            });
+            const activeExecutions = [...runningExecutions, ...startingExecutions];
+            if (activeExecutions.length === 0) {
+                this.log(styles.muted('\nNo running executions found.\n'));
+                return;
+            }
+            // Check if JSON output mode is active
+            const jsonMode = shouldOutputJson(flags);
+            // In JSON mode, output execution selection prompt
+            if (jsonMode) {
+                const execChoices = activeExecutions.map((e) => ({
+                    name: `${e.id} - ${e.ticketId} (${e.agentName}, ${e.environment})`,
+                    value: e.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'executionId', 'Select execution to stop:', execChoices), createMetadata('execution stop', flags));
+                return;
+            }
+            const { selectedId } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedId',
+                    message: 'Select execution to stop:',
+                    choices: activeExecutions.map((e) => ({
+                        name: `${e.id} - ${e.ticketId} (${e.agentName}, ${e.environment})`,
+                        value: e.id,
+                    })),
+                },
+            ]);
+            id = selectedId;
+        }
+        // Get execution
+        const execution = executionStorage.getExecution(id);
+        if (!execution) {
+            this.error(`Execution "${id}" not found.`);
+        }
+        // Check if already stopped
+        if (!['starting', 'running'].includes(execution.status)) {
+            this.log(styles.muted(`\nExecution ${id} is not running (status: ${execution.status}).\n`));
+            return;
+        }
+        // Stop the execution
+        this.log('');
+        this.log(styles.muted(`Stopping ${execution.id}...`));
+        const stopped = await this.stopExecution(execution, flags.force || false);
+        if (stopped) {
+            // Update execution status
+            executionStorage.updateStatus(execution.id, 'stopped');
+            this.log('');
+            this.log(styles.success(`✓ Stopped execution ${execution.id}`));
+            this.log(styles.muted(`   Ticket: ${execution.ticketId}`));
+            this.log(styles.muted(`   Agent: ${execution.agentName}`));
+            this.log('');
+        }
+    }
+    async stopExecution(execution, force) {
+        try {
+            // First try to kill any tmux session (all environments use tmux for session management)
+            if (execution.sessionId) {
+                try {
+                    // Try to kill the tmux session
+                    if (execution.environment === 'devcontainer' && execution.containerId) {
+                        // Kill tmux session inside container
+                        execSync(`docker exec ${execution.containerId} tmux kill-session -t "${execution.sessionId}"`, { stdio: 'pipe' });
+                    }
+                    else {
+                        // Kill host tmux session
+                        execSync(`tmux kill-session -t "${execution.sessionId}"`, { stdio: 'pipe' });
+                    }
+                }
+                catch {
+                    // Session may not exist
+                }
+            }
+            // Handle environment-specific cleanup
+            switch (execution.environment) {
+                case 'host':
+                    // Kill process if we have a PID
+                    if (execution.pid) {
+                        const signal = force ? 'SIGKILL' : 'SIGTERM';
+                        try {
+                            process.kill(parseInt(execution.pid), signal);
+                        }
+                        catch {
+                            // Process may have already exited
+                        }
+                    }
+                    return true;
+                case 'docker':
+                case 'devcontainer':
+                    if (execution.containerId) {
+                        if (!isDockerRunning()) {
+                            this.warn('Docker is not running. Cannot stop container.');
+                            return true;
+                        }
+                        // Note: We don't stop the container itself, just the tmux session inside
+                        // The container can be reused for future work
+                    }
+                    return true;
+                case 'vm':
+                    if (execution.host && execution.sessionId) {
+                        this.warn(`Cannot automatically stop VM execution. SSH to ${execution.host} and stop manually.`);
+                    }
+                    return true;
+                default:
+                    this.warn(`Unknown environment: ${execution.environment}`);
+                    return true;
+            }
+        }
+        catch (error) {
+            this.warn(`Error stopping execution: ${error instanceof Error ? error.message : error}`);
+            return true;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class GH extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/gh/index.js

@@ -0,0 +1,53 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class GH extends Command {
+    static description = 'GitHub CLI setup and status for PR workflow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> status',
+        '<%= config.bin %> <%= command.id %> login',
+        '<%= config.bin %> <%= command.id %> token',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(GH);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        const menuChoices = [
+            { name: 'Check status', value: 'status' },
+            { name: 'Login to GitHub', value: 'login' },
+            { name: 'Show GH_TOKEN setup', value: 'token' },
+        ];
+        const message = 'GitHub CLI Setup';
+        // In JSON mode, output menu prompt
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, menuChoices), createMetadata('gh', flags));
+            return;
+        }
+        // Interactive menu when no subcommand provided
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message,
+                choices: menuChoices,
+            }]);
+        switch (action) {
+            case 'status':
+                await this.config.runCommand('gh status');
+                break;
+            case 'login':
+                await this.config.runCommand('gh login');
+                break;
+            case 'token':
+                await this.config.runCommand('gh token');
+                break;
+        }
+    }
+}

package/dist/commands/gh/login.d.ts

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

package/dist/commands/gh/login.js

@@ -0,0 +1,57 @@
+import { Command } from '@oclif/core';
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+import { styles } from '../../lib/styles.js';
+import { isGHInstalled, isGHAuthenticated, getGHUsername } from '../../lib/pr/index.js';
+export default class GHLogin extends Command {
+    static description = 'Login to GitHub CLI for PR workflow';
+    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 with Homebrew:'));
+            this.log(chalk.cyan('      brew install gh'));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    Or see: https://cli.github.com/'));
+            return;
+        }
+        // Check if already authenticated
+        if (isGHAuthenticated()) {
+            const username = getGHUsername();
+            this.log(chalk.green(`Already authenticated${username ? ` as ${chalk.bold(username)}` : ''}`));
+            this.log(styles.muted(''));
+            this.log(styles.muted('To re-authenticate or switch accounts, run directly:'));
+            this.log(chalk.cyan('  gh auth login'));
+            return;
+        }
+        this.log(styles.muted('Starting GitHub authentication...\n'));
+        // Run gh auth login interactively
+        const child = spawn('gh', ['auth', 'login'], {
+            stdio: 'inherit',
+            shell: true,
+        });
+        await new Promise((resolve, reject) => {
+            child.on('close', (code) => {
+                if (code === 0) {
+                    this.log(chalk.green('\n✓ Successfully authenticated!'));
+                    this.log(styles.muted(''));
+                    this.log(styles.muted('Next, set up GH_TOKEN for devcontainers:'));
+                    this.log(chalk.cyan('  prlt gh token'));
+                    resolve();
+                }
+                else {
+                    this.log(chalk.yellow('\nAuthentication cancelled or failed.'));
+                    resolve();
+                }
+            });
+            child.on('error', (err) => {
+                this.log(chalk.red(`\nFailed to run gh auth login: ${err.message}`));
+                reject(err);
+            });
+        });
+    }
+}

package/dist/commands/gh/status.d.ts

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

package/dist/commands/gh/status.js

@@ -0,0 +1,48 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import { styles } from '../../lib/styles.js';
+import { isGHInstalled, isGHAuthenticated, getGHUsername, isGHTokenInEnv } from '../../lib/pr/index.js';
+export default class GHStatus extends Command {
+    static description = 'Check GitHub CLI status for PR workflow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        this.log(styles.muted('Checking GitHub CLI status...\n'));
+        // Check if gh is installed
+        if (!isGHInstalled()) {
+            this.log(chalk.red('  ✗ gh CLI not installed'));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    Install with Homebrew:'));
+            this.log(chalk.cyan('      brew install gh'));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    Or see: https://cli.github.com/'));
+            return;
+        }
+        this.log(chalk.green('  ✓ gh CLI installed'));
+        // Check if gh is authenticated
+        if (!isGHAuthenticated()) {
+            this.log(chalk.yellow('  ⚠ gh CLI not authenticated'));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    Run to authenticate:'));
+            this.log(chalk.cyan('      prlt gh login'));
+            this.log(styles.muted(''));
+            return;
+        }
+        const username = getGHUsername();
+        this.log(chalk.green(`  ✓ Authenticated${username ? ` as ${chalk.bold(username)}` : ''}`));
+        // Check if GH_TOKEN is available for devcontainers
+        if (isGHTokenInEnv()) {
+            this.log(chalk.green('  ✓ GH_TOKEN available for devcontainers'));
+            this.log(styles.muted(''));
+            this.log(chalk.green('All set! PR creation will work in both host and devcontainers.'));
+        }
+        else {
+            this.log(chalk.yellow('  ⚠ GH_TOKEN not set'));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    PR creation works on host, but not in devcontainers.'));
+            this.log(styles.muted('    Run to see setup instructions:'));
+            this.log(chalk.cyan('      prlt gh token'));
+        }
+    }
+}

package/dist/commands/gh/token.d.ts

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