@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/work/complete.js

@@ -0,0 +1,121 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
+import { getWorkColumnSetting, findColumnByName } from '../../lib/pmo/utils.js';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/storage.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class WorkComplete extends PMOCommand {
+    static description = 'Mark work as complete (moves ticket to Done column)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> TKT-001',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(WorkComplete);
+        const projectId = flags.project;
+        // 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('work complete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get workspace info for execution storage
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            return handleError('NOT_IN_WORKSPACE', 'Not in a workspace. Run "prlt init" first.');
+        }
+        // Open database for execution storage
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        const db = new Database(dbPath);
+        const executionStorage = new ExecutionStorage(db);
+        try {
+            // Get ticketId - prompt if not provided
+            let ticketId = args.ticketId;
+            if (!ticketId) {
+                // Get all tickets that could be completed (in progress / started), optionally filtered by project
+                const allTickets = await this.storage.listTickets(projectId);
+                const completableTickets = allTickets.filter(t => t.statusCategory === 'started' || (t.statusName && t.statusName.toLowerCase().includes('progress')));
+                if (completableTickets.length === 0) {
+                    db.close();
+                    if (jsonMode) {
+                        outputErrorAsJson('NO_COMPLETABLE_WORK', 'No in-progress work found.', createMetadata('work complete', flags));
+                        return;
+                    }
+                    this.log(styles.info('No in-progress work found.'));
+                    return;
+                }
+                const selected = await this.selectFromList({
+                    message: 'Select work to mark as complete:',
+                    items: completableTickets,
+                    getName: (t) => `${t.id} - ${t.title} (${t.statusName})`,
+                    getValue: (t) => t.id,
+                    getCommand: (t) => `prlt work complete ${t.id} --json`,
+                    jsonMode: jsonMode ? { flags, commandName: 'work complete' } : null,
+                });
+                if (!selected) {
+                    db.close();
+                    return;
+                }
+                ticketId = selected;
+            }
+            // Get ticket
+            const ticket = await this.storage.getTicket(ticketId);
+            if (!ticket) {
+                db.close();
+                this.error(`Ticket "${ticketId}" not found.`);
+            }
+            // Get configured column name (from pmo_settings or default)
+            const targetColumnName = getWorkColumnSetting(db, 'done');
+            const board = await this.storage.getBoard(ticket.projectId);
+            const columnNames = board.columns.map(col => col.name);
+            const doneColumn = findColumnByName(columnNames, targetColumnName);
+            if (!doneColumn) {
+                db.close();
+                this.error(`No "${targetColumnName}" column found in board configuration. Configure with: prlt config set column_done <column-name>`);
+            }
+            const previousColumn = ticket.statusName;
+            // Move to Done column (moveTicket also updates status_id)
+            await this.storage.moveTicket(ticket.projectId, ticketId, doneColumn);
+            // Auto-export to board.md if configured
+            await autoExportToBoard(this.pmoPath, this.storage);
+            // Mark any running executions for this ticket as completed
+            const runningExecution = executionStorage.getRunningExecution(ticketId);
+            if (runningExecution) {
+                executionStorage.updateStatus(runningExecution.id, 'completed');
+                this.log(styles.muted(`   Execution ${runningExecution.id} marked as completed`));
+            }
+            db.close();
+            this.log(styles.success(`Work complete: ${ticketId}`));
+            this.log(styles.muted(`   Title: ${ticket.title}`));
+            this.log(styles.muted(`   From: ${previousColumn}`));
+            this.log(styles.muted(`   To: ${doneColumn}`));
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+}

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

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

@@ -0,0 +1,70 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, } from '../../lib/prompt-json.js';
+export default class Work extends PMOCommand {
+    static description = 'Interactive menu for work operations (ownership, assignment, execution)';
+    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() {
+        // Prompt for project selection so we can pass it to subcommands
+        return { promptIfMultiple: true };
+    }
+    async execute() {
+        const { flags } = await this.parse(Work);
+        // This command requires project context - get it once and reuse
+        const projectId = await this.requireProject();
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        // Execution actions first (most common), then ownership
+        // Each choice includes the full command for AI agents to execute
+        const menuChoices = [
+            { id: 'start', name: 'Start work (launch single agent)', command: `prlt work start -P ${projectId} --json` },
+            { id: 'spawn', name: 'Spawn work (batch by column)', command: `prlt work spawn -P ${projectId} --json` },
+            { id: 'watch', name: 'Watch column (auto-spawn)', command: `prlt work watch -P ${projectId} --json` },
+            { id: 'ready', name: 'Mark work ready for review', command: `prlt work ready -P ${projectId} --json` },
+            { id: 'complete', name: 'Mark work complete', command: `prlt work complete -P ${projectId} --json` },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'Work Operations - 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: 'work' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            return;
+        }
+        // Run the selected subcommand
+        // Pass --project to avoid re-prompting for project selection
+        const projectArgs = ['--project', projectId];
+        switch (action) {
+            case 'start':
+                await this.config.runCommand('work:start', projectArgs);
+                break;
+            case 'spawn':
+                await this.config.runCommand('work:spawn', projectArgs);
+                break;
+            case 'watch':
+                await this.config.runCommand('work:watch', projectArgs);
+                break;
+            case 'ready':
+                await this.config.runCommand('work:ready', projectArgs);
+                break;
+            case 'complete':
+                await this.config.runCommand('work:complete', projectArgs);
+                break;
+        }
+    }
+}

package/dist/commands/work/ready.d.ts

@@ -0,0 +1,24 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkReady extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        pr: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        draft: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-pr': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    /**
+     * Check if we should offer PR creation (gh is available, on a feature branch, etc.)
+     */
+    private shouldOfferPRCreation;
+    /**
+     * Handle PR creation for the ticket.
+     */
+    private handlePRCreation;
+}

package/dist/commands/work/ready.js

@@ -0,0 +1,290 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import Database from 'better-sqlite3';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
+import { getWorkColumnSetting, findColumnByName } from '../../lib/pmo/utils.js';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/storage.js';
+import { isGHInstalled, isGHAuthenticated, getCurrentBranch, getDefaultBaseBranch, hasBranchBeenPushed, pushBranch, hasUnpushedCommits, getCommitLog, createPR, getPRForBranch, generatePRTitle, generatePRBody, } from '../../lib/pr/index.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class WorkReady extends PMOCommand {
+    static description = 'Mark work as ready for review (moves ticket to In Review column)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> TKT-001',
+        '<%= config.bin %> <%= command.id %> --pr',
+        '<%= config.bin %> <%= command.id %> TKT-001 --pr --draft',
+        '<%= config.bin %> <%= command.id %> --json  # Output choices as JSON',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        pr: Flags.boolean({
+            description: 'Create a pull request for this work',
+            default: false,
+        }),
+        draft: Flags.boolean({
+            description: 'Create PR as draft (only with --pr)',
+            default: false,
+        }),
+        'no-pr': Flags.boolean({
+            description: 'Skip PR creation prompt',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(WorkReady);
+        const projectId = flags.project;
+        // 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('work ready', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get workspace info for execution storage
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            return handleError('NOT_IN_WORKSPACE', 'Not in a workspace. Run "prlt init" first.');
+        }
+        // Open database for execution storage
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        const db = new Database(dbPath);
+        const executionStorage = new ExecutionStorage(db);
+        try {
+            // Get ticketId - prompt if not provided
+            let ticketId = args.ticketId;
+            if (!ticketId) {
+                // Get all in-progress (started) tickets for selection, optionally filtered by project
+                const allTickets = await this.storage.listTickets(projectId);
+                const inProgressTickets = allTickets.filter(t => t.statusCategory === 'started' || (t.statusName && t.statusName.toLowerCase().includes('progress')));
+                if (inProgressTickets.length === 0) {
+                    db.close();
+                    if (jsonMode) {
+                        outputErrorAsJson('NO_IN_PROGRESS_WORK', 'No in-progress work found.', createMetadata('work ready', flags));
+                        return;
+                    }
+                    this.log(styles.info('No in-progress work found.'));
+                    return;
+                }
+                const selected = await this.selectFromList({
+                    message: 'Select work to mark as ready for review:',
+                    items: inProgressTickets,
+                    getName: (t) => `${t.id} - ${t.title} (${t.statusName})`,
+                    getValue: (t) => t.id,
+                    getCommand: (t) => `prlt work ready ${t.id} --json`,
+                    jsonMode: jsonMode ? { flags, commandName: 'work ready' } : null,
+                });
+                if (!selected) {
+                    db.close();
+                    return;
+                }
+                ticketId = selected;
+            }
+            // Get ticket
+            const ticket = await this.storage.getTicket(ticketId);
+            if (!ticket) {
+                db.close();
+                this.error(`Ticket "${ticketId}" not found.`);
+            }
+            // Get configured column name (from pmo_settings or default)
+            // In Linear-style workflow, "ready" moves ticket to Done (review is implicit via PR)
+            const targetColumnName = getWorkColumnSetting(db, 'done');
+            const board = await this.storage.getBoard(ticket.projectId);
+            const columnNames = board.columns.map(col => col.name);
+            const doneColumn = findColumnByName(columnNames, targetColumnName);
+            if (!doneColumn) {
+                db.close();
+                this.error(`No "${targetColumnName}" column found in board configuration. Configure with: prlt config set column_done <column-name>`);
+            }
+            const previousColumn = ticket.statusName;
+            // Move to Done column (moveTicket also updates status_id)
+            await this.storage.moveTicket(ticket.projectId, ticketId, doneColumn);
+            // Auto-export to board.md if configured
+            await autoExportToBoard(this.pmoPath, this.storage);
+            // Mark any running executions for this ticket as completed
+            const runningExecution = executionStorage.getRunningExecution(ticketId);
+            if (runningExecution) {
+                executionStorage.updateStatus(runningExecution.id, 'completed');
+                this.log(styles.muted(`   Execution ${runningExecution.id} marked as completed`));
+            }
+            // Handle PR creation
+            let prUrl;
+            const shouldCreatePR = flags.pr || (!flags['no-pr'] && await this.shouldOfferPRCreation());
+            if (shouldCreatePR) {
+                // Get branch and worktree path from the execution record
+                const branch = runningExecution?.branch;
+                const agentName = runningExecution?.agentName;
+                let worktreePath;
+                if (agentName) {
+                    // Get agent's worktree path
+                    if (process.env.DEVCONTAINER === 'true') {
+                        // In devcontainer, look for repo directories inside /workspace
+                        const entries = fs.readdirSync('/workspace', { withFileTypes: true });
+                        const repoDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules');
+                        if (repoDirs.length > 0) {
+                            // Use the first repo directory (typically proletariat-{agentName})
+                            worktreePath = path.join('/workspace', repoDirs[0].name);
+                        }
+                    }
+                    else {
+                        const agentsPath = path.join(workspaceInfo.path, 'agents', 'staff');
+                        const agentDir = path.join(agentsPath, agentName);
+                        // Look for repo directories inside agent dir
+                        const entries = fs.readdirSync(agentDir, { withFileTypes: true });
+                        const repoDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules');
+                        if (repoDirs.length > 0) {
+                            // Use the first repo directory (typically the main worktree)
+                            worktreePath = path.join(agentDir, repoDirs[0].name);
+                        }
+                    }
+                }
+                prUrl = await this.handlePRCreation(ticket, flags.draft, branch, worktreePath);
+                if (prUrl) {
+                    // Store PR URL in ticket metadata
+                    await this.storage.updateTicket(ticketId, {
+                        metadata: {
+                            ...ticket.metadata,
+                            pr_url: prUrl,
+                        },
+                    });
+                }
+            }
+            db.close();
+            this.log(styles.success(`Work ready: ${ticketId}`));
+            this.log(styles.muted(`   Title: ${ticket.title}`));
+            this.log(styles.muted(`   From: ${previousColumn}`));
+            this.log(styles.muted(`   To: ${doneColumn}`));
+            if (prUrl) {
+                this.log(styles.muted(`   PR: ${prUrl}`));
+            }
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+    /**
+     * Check if we should offer PR creation (gh is available, on a feature branch, etc.)
+     */
+    async shouldOfferPRCreation() {
+        // Check if gh CLI is available
+        if (!isGHInstalled() || !isGHAuthenticated()) {
+            return false;
+        }
+        // Check if we're on a feature branch (not main/master)
+        const currentBranch = getCurrentBranch();
+        if (!currentBranch) {
+            return false;
+        }
+        const baseBranch = getDefaultBaseBranch();
+        if (currentBranch === baseBranch) {
+            return false;
+        }
+        // Check if PR already exists
+        const existingPR = getPRForBranch(currentBranch);
+        if (existingPR) {
+            this.log(styles.muted(`   PR already exists: ${existingPR.url}`));
+            return false;
+        }
+        // Prompt user
+        const { createPR: wantPR } = await inquirer.prompt([{
+                type: 'list',
+                name: 'createPR',
+                message: 'Create a pull request for this work?',
+                choices: [
+                    { name: 'Yes', value: true },
+                    { name: 'No', value: false },
+                ],
+                default: true,
+            }]);
+        return wantPR;
+    }
+    /**
+     * Handle PR creation for the ticket.
+     */
+    async handlePRCreation(ticket, draft, branchFromExecution, worktreePath) {
+        // Use branch from execution record if available, otherwise try to detect
+        const currentBranch = branchFromExecution || getCurrentBranch();
+        if (!currentBranch) {
+            this.log(styles.warning('Could not determine current branch. Skipping PR creation.'));
+            return undefined;
+        }
+        // If we have a worktree path, cd to it for git operations
+        const originalCwd = process.cwd();
+        if (worktreePath) {
+            try {
+                process.chdir(worktreePath);
+            }
+            catch {
+                this.log(styles.warning(`Could not access worktree at ${worktreePath}. Skipping PR creation.`));
+                return undefined;
+            }
+        }
+        try {
+            const baseBranch = getDefaultBaseBranch();
+            // Push branch if needed
+            if (!hasBranchBeenPushed(currentBranch)) {
+                this.log(styles.muted(`   Pushing branch to origin...`));
+                if (!pushBranch(currentBranch)) {
+                    this.log(styles.warning('Failed to push branch. Skipping PR creation.'));
+                    return undefined;
+                }
+            }
+            else if (hasUnpushedCommits(currentBranch)) {
+                this.log(styles.muted(`   Pushing unpushed commits...`));
+                if (!pushBranch(currentBranch)) {
+                    this.log(styles.warning('Failed to push commits. Skipping PR creation.'));
+                    return undefined;
+                }
+            }
+            // Generate PR content
+            const prTitle = generatePRTitle(ticket.id, ticket.title);
+            const commits = getCommitLog(baseBranch);
+            const prBody = generatePRBody({
+                ticketId: ticket.id,
+                ticketTitle: ticket.title,
+                ticketDescription: ticket.description,
+                commits: commits.slice(0, 10),
+            });
+            // Create PR
+            this.log(styles.muted(`   Creating pull request...`));
+            const result = createPR({
+                title: prTitle,
+                body: prBody,
+                base: baseBranch,
+                draft,
+            });
+            if (!result.success) {
+                this.log(styles.warning(`Failed to create PR: ${result.error}`));
+                return undefined;
+            }
+            this.log(styles.success(`   PR #${result.number} created`));
+            return result.url;
+        }
+        finally {
+            // Restore original cwd
+            if (worktreePath) {
+                process.chdir(originalCwd);
+            }
+        }
+    }
+}

package/dist/commands/work/revise.d.ts

@@ -0,0 +1,19 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkRevise extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        mode: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        executor: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'run-on-host': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        session: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private getCurrentBranch;
+}