@proletariat/cli 0.1.4 → 0.3.0

package/dist/commands/pmo/init.js

@@ -0,0 +1,341 @@
+import { Command, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import Database from 'better-sqlite3';
+import { SQLiteStorage, getColumnsForTemplate, createPMO, promptForPMOLocation, promptForBoardTemplate, promptForBoardName, promptForCustomColumns, determinePMOPath, } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { isGHInstalled, isGHAuthenticated, getGHUsername, isGHTokenInEnv } from '../../lib/pr/index.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class PMOInit extends Command {
+    static description = 'Initialize PMO (Project Management Office) in current directory or HQ';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --location repo:proletariat --template founder',
+        '<%= config.bin %> <%= command.id %> --location separate --template scrum',
+    ];
+    static flags = {
+        location: Flags.string({
+            char: 'l',
+            description: 'PMO location (separate or repo:name)',
+        }),
+        template: Flags.string({
+            char: 't',
+            description: 'Board template',
+            options: ['kanban', 'scrum', 'founder', 'custom'],
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Board name',
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PMOInit);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Check if PMO already exists
+        const hqRoot = this.findHQRoot();
+        let existingPMO = false;
+        let projectCount = 0;
+        let ticketCount = 0;
+        if (hqRoot) {
+            const dbPath = path.join(hqRoot, '.proletariat', 'workspace.db');
+            if (fs.existsSync(dbPath)) {
+                try {
+                    const db = new Database(dbPath);
+                    const result = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='pmo_projects'").get();
+                    if (result !== undefined) {
+                        existingPMO = true;
+                        // Get counts
+                        const projectCountResult = db.prepare('SELECT COUNT(*) as count FROM pmo_projects').get();
+                        const ticketCountResult = db.prepare('SELECT COUNT(*) as count FROM pmo_tickets').get();
+                        projectCount = projectCountResult.count;
+                        ticketCount = ticketCountResult.count;
+                    }
+                    db.close();
+                }
+                catch (error) {
+                    // Log error for debugging
+                    console.error('PMO check error:', error);
+                    // Ignore errors - database might not be initialized yet
+                }
+            }
+        }
+        // If PMO exists, prompt for reinitialize
+        if (existingPMO) {
+            const shouldReinitialize = await this.promptReinitialize(hqRoot, projectCount, ticketCount, jsonMode, flags);
+            if (shouldReinitialize === null) {
+                // JSON mode returned early
+                return;
+            }
+            if (!shouldReinitialize) {
+                this.log(chalk.yellow('\nCancelled. Existing PMO preserved.'));
+                return;
+            }
+            // Delete existing PMO
+            await this.deletePMO(hqRoot);
+        }
+        this.log(chalk.blue('🎯 Initializing PMO...\n'));
+        this.log(chalk.gray('   Creates board.md and specs/ for project planning'));
+        this.log(chalk.gray('   (Data stored in SQLite, synced to markdown files)\n'));
+        // Get PMO location using shared prompt (or from flag)
+        let location;
+        if (flags.location) {
+            location = flags.location;
+        }
+        else {
+            location = await promptForPMOLocation(hqRoot);
+        }
+        // Get board template using shared prompt (or from flag)
+        let template;
+        if (flags.template) {
+            template = flags.template;
+        }
+        else {
+            template = await promptForBoardTemplate();
+        }
+        // Get columns for template
+        let columns = getColumnsForTemplate(template);
+        if (template === 'custom') {
+            columns = await promptForCustomColumns();
+        }
+        // Get board name using shared prompt (or from flag)
+        // Default to {hqname}-kanban pattern
+        const hqName = hqRoot ? path.basename(hqRoot).replace(/-hq$/, '') : undefined;
+        const defaultBoardName = hqName ? `${hqName}-kanban` : undefined;
+        const boardName = flags.name || await promptForBoardName(defaultBoardName);
+        // For standalone PMO (no HQ), we need to create mini-HQ structure first
+        const isStandalone = !hqRoot;
+        let effectiveHqPath;
+        if (isStandalone) {
+            // Create mini-HQ structure
+            effectiveHqPath = path.join(process.cwd(), '.pmo');
+            await this.createStandaloneHQ(effectiveHqPath);
+        }
+        else {
+            effectiveHqPath = hqRoot;
+        }
+        // Use shared createPMO function
+        await createPMO({
+            hqPath: effectiveHqPath,
+            location,
+            boardTemplate: template,
+            boardName,
+            columns,
+            storageType: 'sqlite',
+        });
+        // Initialize git for separate PMO (recommended for syncing across machines)
+        if (location === 'separate' && !isStandalone) {
+            const pmoPath = determinePMOPath(effectiveHqPath, location);
+            await this.initGitForPMO(pmoPath);
+        }
+        this.log(chalk.green('\n✅ PMO initialized successfully!'));
+        // Check GitHub CLI setup for PR workflow
+        this.checkGitHubCLI();
+        this.logNextSteps();
+    }
+    /**
+     * Create standalone mini-HQ structure for PMO outside of an HQ
+     */
+    async createStandaloneHQ(hqPath) {
+        const proletariatPath = path.join(hqPath, '.proletariat');
+        fs.mkdirSync(proletariatPath, { recursive: true });
+        // Create minimal config
+        const config = {
+            type: 'hq',
+            name: 'PMO',
+            created: new Date().toISOString(),
+            version: '2.0.0',
+        };
+        fs.writeFileSync(path.join(proletariatPath, 'config.json'), JSON.stringify(config, null, 2));
+        // Create workspace.db using SQLiteStorage (which creates tables)
+        const dbPath = path.join(proletariatPath, 'workspace.db');
+        const storage = new SQLiteStorage(dbPath);
+        await storage.close();
+        this.log(chalk.green('  ✓ Standalone PMO structure created'));
+    }
+    findHQRoot() {
+        let currentDir = process.cwd();
+        while (currentDir !== '/') {
+            const configPath = path.join(currentDir, '.proletariat', 'config.json');
+            if (fs.existsSync(configPath)) {
+                try {
+                    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                    if (config.type === 'hq') {
+                        return currentDir;
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        return null;
+    }
+    async promptReinitialize(hqRoot, projectCount, ticketCount, jsonMode = false, flags = {}) {
+        // Find PMO location from database
+        const dbPath = path.join(hqRoot, '.proletariat', 'workspace.db');
+        let pmoPath = path.join(hqRoot, 'pmo'); // Default fallback
+        try {
+            const db = new Database(dbPath);
+            const result = db.prepare('SELECT value FROM pmo_settings WHERE key = ?').get('pmo_path');
+            if (result) {
+                pmoPath = result.value;
+            }
+            db.close();
+        }
+        catch {
+            // Use default if table doesn't exist
+        }
+        // Define choices once, use for both JSON and interactive modes
+        const actionChoices = [
+            { name: 'Cancel (keep existing PMO)', value: 'cancel' },
+            { name: 'Reinitialize (DELETES all data)', value: 'reinitialize' },
+        ];
+        const message = `PMO already exists at ${pmoPath} (${projectCount} projects, ${ticketCount} tickets). What would you like to do?`;
+        // In JSON mode, output reinitialize prompt and exit
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, actionChoices), createMetadata('pmo init', flags));
+        }
+        this.log(chalk.yellow('\n⚠️  PMO already exists'));
+        this.log(chalk.gray(`   Location: ${pmoPath}`));
+        this.log(chalk.gray(`   Projects: ${projectCount}`));
+        this.log(chalk.gray(`   Tickets: ${ticketCount}\n`));
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: actionChoices,
+                default: 'cancel',
+            }]);
+        if (action === 'cancel') {
+            return false;
+        }
+        // Show warning and require typed confirmation
+        this.log(chalk.red('\n⚠️  WARNING: This will permanently delete:'));
+        this.log(chalk.red('   • All tickets and boards'));
+        this.log(chalk.red('   • All specs and documentation'));
+        this.log(chalk.red('   • Database tables (pmo_*)\n'));
+        const { confirmation } = await inquirer.prompt([{
+                type: 'input',
+                name: 'confirmation',
+                message: 'Type "delete pmo" to confirm:',
+            }]);
+        if (confirmation !== 'delete pmo') {
+            this.log(chalk.yellow('\nCancelled. Confirmation text did not match.'));
+            return false;
+        }
+        return true;
+    }
+    async deletePMO(hqRoot) {
+        this.log(chalk.blue('\n🗑️  Deleting existing PMO...\n'));
+        // Delete database tables and get PMO path before dropping settings
+        const dbPath = path.join(hqRoot, '.proletariat', 'workspace.db');
+        let pmoPath = path.join(hqRoot, 'pmo'); // Default fallback
+        if (fs.existsSync(dbPath)) {
+            const db = new Database(dbPath);
+            // Get PMO path from database before deleting
+            try {
+                const result = db.prepare('SELECT value FROM pmo_settings WHERE key = ?').get('pmo_path');
+                if (result) {
+                    pmoPath = result.value;
+                }
+            }
+            catch {
+                // Ignore - table might not exist, use default
+            }
+            // Drop all pmo_* tables
+            const tables = ['pmo_ticket_specs', 'pmo_ticket_metadata', 'pmo_subtasks', 'pmo_tickets',
+                'pmo_columns', 'pmo_specs', 'pmo_epics', 'pmo_projects',
+                'pmo_initiatives', 'pmo_ticket_assignments', 'pmo_cache_metadata', 'pmo_settings'];
+            for (const table of tables) {
+                try {
+                    db.prepare(`DROP TABLE IF EXISTS ${table}`).run();
+                }
+                catch {
+                    // Ignore errors - table might not exist
+                }
+            }
+            db.close();
+            this.log(chalk.green('  ✓ Dropped database tables'));
+        }
+        // Delete pmo/ directory (using path from database or default)
+        if (fs.existsSync(pmoPath)) {
+            fs.rmSync(pmoPath, { recursive: true, force: true });
+            this.log(chalk.green('  ✓ Removed pmo/ directory\n'));
+        }
+    }
+    async initGitForPMO(pmoPath) {
+        try {
+            // Create .gitignore
+            const gitignore = `# Proletariat PMO
+.DS_Store
+*.swp
+*.swo
+*~
+.vscode/
+.idea/
+`;
+            fs.writeFileSync(path.join(pmoPath, '.gitignore'), gitignore);
+            // Initialize git repo
+            execSync('git init', { cwd: pmoPath, stdio: 'pipe' });
+            execSync('git add .', { cwd: pmoPath, stdio: 'pipe' });
+            execSync('git commit -m "Initialize PMO\n\nCreated with Proletariat CLI"', { cwd: pmoPath, stdio: 'pipe' });
+            this.log(chalk.green('  ✓ Git repository initialized'));
+            this.log(styles.muted('    Add remote: cd pmo && git remote add origin <url>'));
+        }
+        catch {
+            this.log(chalk.yellow('  ⚠ Git initialization failed (continuing without git)'));
+            this.log(styles.muted('    You can initialize git manually: cd pmo && git init'));
+        }
+    }
+    logNextSteps() {
+        this.log(styles.muted('\nNext steps:'));
+        this.log(styles.muted('  1. Create your first ticket: prlt ticket create'));
+        this.log(styles.muted('  2. Create a spec: prlt spec create'));
+        this.log(styles.muted('  3. Open pmo/ in Obsidian for visual kanban'));
+    }
+    /**
+     * Check GitHub CLI setup and provide guidance for PR workflow
+     */
+    checkGitHubCLI() {
+        this.log(styles.muted('\nChecking GitHub CLI for PR workflow...'));
+        // Check if gh is installed
+        if (!isGHInstalled()) {
+            this.log(chalk.yellow('  ⚠ gh CLI not installed'));
+            this.log(styles.muted('    Install: brew install gh'));
+            this.log(styles.muted('    PR creation will be skipped without gh\n'));
+            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('    Run: gh auth login'));
+            this.log(styles.muted('    PR creation will be skipped without auth\n'));
+            return;
+        }
+        const username = getGHUsername();
+        this.log(chalk.green(`  ✓ gh authenticated${username ? ` as ${username}` : ''}`));
+        // Check if GH_TOKEN is available for devcontainers
+        if (isGHTokenInEnv()) {
+            this.log(chalk.green('  ✓ GH_TOKEN available for devcontainers'));
+        }
+        else {
+            this.log(chalk.yellow('  ⚠ GH_TOKEN not set (needed for PR creation in devcontainers)'));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    To enable PR creation from devcontainers, add to your shell profile:'));
+            this.log(styles.muted(''));
+            this.log(chalk.cyan("      echo 'export GH_TOKEN=$(gh auth token 2>/dev/null)' >> ~/.zshrc"));
+            this.log(styles.muted(''));
+            this.log(styles.muted('    Then restart your terminal or run: source ~/.zshrc'));
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class PRCreate extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        base: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        draft: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-link': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        title: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        body: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/pr/create.js

@@ -0,0 +1,242 @@
+import { Command, Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import inquirer from 'inquirer';
+import { getPMOContext } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { isGHInstalled, isGHAuthenticated, getCurrentBranch, getDefaultBaseBranch, hasBranchBeenPushed, pushBranch, hasUnpushedCommits, getCommitLog, createPR, getPRForBranch, generatePRTitle, generatePRBody, } from '../../lib/pr/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class PRCreate extends Command {
+    static description = 'Create a GitHub pull request from the current branch';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> TKT-001',
+        '<%= config.bin %> <%= command.id %> --draft',
+        '<%= config.bin %> <%= command.id %> --base develop',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID to link to PR - auto-detects from branch if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        base: Flags.string({
+            char: 'b',
+            description: 'Base branch for the PR (defaults to main/master)',
+        }),
+        draft: Flags.boolean({
+            char: 'd',
+            description: 'Create as draft PR',
+            default: false,
+        }),
+        'no-link': Flags.boolean({
+            description: 'Skip linking PR to ticket',
+            default: false,
+        }),
+        title: Flags.string({
+            char: 't',
+            description: 'PR title (auto-generated from ticket if not provided)',
+        }),
+        body: Flags.string({
+            description: 'PR body/description',
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PRCreate);
+        // 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('pr create', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Check gh CLI
+        if (!isGHInstalled()) {
+            return handleError('GH_NOT_INSTALLED', 'GitHub CLI (gh) is not installed. Install it from https://cli.github.com/');
+        }
+        if (!isGHAuthenticated()) {
+            return handleError('GH_NOT_AUTHENTICATED', 'GitHub CLI is not authenticated. Run "gh auth login" first.');
+        }
+        // Get current branch
+        const currentBranch = getCurrentBranch();
+        if (!currentBranch) {
+            return handleError('NO_GIT_REPO', 'Not in a git repository or unable to determine current branch.');
+        }
+        // Check if on main/master
+        const baseBranch = flags.base || getDefaultBaseBranch();
+        if (currentBranch === baseBranch) {
+            return handleError('ON_BASE_BRANCH', `Cannot create PR from ${baseBranch} branch. Switch to a feature branch first.`);
+        }
+        // Check if PR already exists for this branch
+        const existingPR = getPRForBranch(currentBranch);
+        if (existingPR) {
+            this.log(styles.info(`PR already exists for branch "${currentBranch}":`));
+            this.log(styles.muted(`   #${existingPR.number}: ${existingPR.title}`));
+            this.log(styles.muted(`   URL: ${existingPR.url}`));
+            return;
+        }
+        // Get workspace and PMO context (optional - PR creation works without it)
+        let workspaceInfo;
+        let storage = null;
+        let db = null;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+            const pmoContext = await getPMOContext({
+                logger: (msg) => this.log(styles.muted(msg)),
+            });
+            storage = pmoContext.storage;
+            db = new Database(path.join(workspaceInfo.path, '.proletariat', 'workspace.db'));
+        }
+        catch {
+            // No workspace - that's fine, we can still create PRs
+            this.log(styles.muted('   No workspace found - creating PR without ticket linking'));
+        }
+        try {
+            // Determine ticket ID
+            let ticketId = args.ticketId;
+            if (!ticketId && !flags['no-link'] && storage) {
+                // Try to extract ticket ID from branch name (e.g., feat/agent/TKT-001-description)
+                const ticketMatch = currentBranch.match(/(TKT-\d+)/i);
+                if (ticketMatch) {
+                    ticketId = ticketMatch[1].toUpperCase();
+                    this.log(styles.muted(`   Auto-detected ticket: ${ticketId}`));
+                }
+            }
+            // Get ticket info if available
+            let ticket = null;
+            if (ticketId && storage) {
+                ticket = await storage.getTicket(ticketId);
+                if (!ticket) {
+                    this.warn(`Ticket "${ticketId}" not found. Continuing without ticket link.`);
+                    ticketId = undefined;
+                }
+            }
+            // If no ticket, prompt for selection (only if we have storage)
+            if (!ticketId && !flags['no-link'] && storage) {
+                const projectId = flags.project;
+                const allTickets = await storage.listTickets(projectId);
+                const inProgressTickets = allTickets.filter(t => t.statusName && t.statusName.toLowerCase().includes('progress'));
+                if (inProgressTickets.length > 0) {
+                    // Build choices once, use for both JSON and interactive modes
+                    const ticketChoices = [
+                        ...inProgressTickets.map(t => ({
+                            name: `${t.id} - ${t.title}`,
+                            value: t.id,
+                        })),
+                        { name: 'Skip - create PR without linking', value: '__skip__' },
+                    ];
+                    const message = 'Link PR to a ticket?';
+                    // In JSON mode, output ticket selection prompt and exit
+                    if (jsonMode) {
+                        outputPromptAsJson(buildPromptConfig('list', 'ticketId', message, ticketChoices), createMetadata('pr create', flags));
+                    }
+                    const { selectedTicketId } = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'selectedTicketId',
+                            message,
+                            choices: [
+                                ...ticketChoices.slice(0, -1),
+                                new inquirer.Separator(),
+                                ticketChoices[ticketChoices.length - 1],
+                            ],
+                        },
+                    ]);
+                    if (selectedTicketId !== '__skip__') {
+                        ticketId = selectedTicketId;
+                        ticket = await storage.getTicket(ticketId);
+                    }
+                }
+            }
+            // Generate PR title and body
+            let prTitle = flags.title;
+            let prBody = flags.body;
+            if (!prTitle) {
+                if (ticket) {
+                    prTitle = generatePRTitle(ticket.id, ticket.title);
+                }
+                else {
+                    // Use branch name as title
+                    const branchParts = currentBranch.split('/');
+                    prTitle = branchParts[branchParts.length - 1].replace(/-/g, ' ');
+                }
+            }
+            if (!prBody && ticket) {
+                const commits = getCommitLog(baseBranch);
+                prBody = generatePRBody({
+                    ticketId: ticket.id,
+                    ticketTitle: ticket.title,
+                    ticketDescription: ticket.description,
+                    commits: commits.slice(0, 10), // Limit to 10 commits
+                });
+            }
+            // Push branch if not pushed
+            if (!hasBranchBeenPushed(currentBranch)) {
+                this.log(styles.muted(`   Pushing branch to origin...`));
+                if (!pushBranch(currentBranch)) {
+                    this.error('Failed to push branch to origin.');
+                }
+            }
+            else if (hasUnpushedCommits(currentBranch)) {
+                this.log(styles.muted(`   Pushing unpushed commits...`));
+                if (!pushBranch(currentBranch)) {
+                    this.error('Failed to push commits to origin.');
+                }
+            }
+            // Create PR
+            this.log('');
+            this.log(styles.header('Creating Pull Request'));
+            this.log(styles.muted(`   Branch: ${currentBranch}`));
+            this.log(styles.muted(`   Base: ${baseBranch}`));
+            this.log(styles.muted(`   Title: ${prTitle}`));
+            if (flags.draft) {
+                this.log(styles.muted(`   Draft: yes`));
+            }
+            const result = createPR({
+                title: prTitle,
+                body: prBody,
+                base: baseBranch,
+                draft: flags.draft,
+            });
+            if (!result.success) {
+                this.error(`Failed to create PR: ${result.error}`);
+            }
+            // Store PR URL in ticket metadata
+            if (ticket && result.url && storage) {
+                await storage.updateTicket(ticket.id, {
+                    metadata: {
+                        pr_url: result.url,
+                        pr_number: String(result.number),
+                    },
+                });
+            }
+            if (storage)
+                await storage.close();
+            if (db)
+                db.close();
+            this.log('');
+            this.log(styles.success(`Pull request created!`));
+            this.log(styles.muted(`   PR #${result.number}`));
+            this.log(styles.muted(`   URL: ${result.url}`));
+            if (ticket) {
+                this.log(styles.muted(`   Linked to: ${ticket.id}`));
+            }
+        }
+        catch (error) {
+            if (storage)
+                await storage.close();
+            if (db)
+                db.close();
+            throw error;
+        }
+    }
+}

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

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

package/dist/commands/pr/index.js

@@ -0,0 +1,68 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { findPMO } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class PR extends Command {
+    static description = 'Interactive menu for pull request operations';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PR);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        const pmoPath = findPMO();
+        if (!pmoPath) {
+            if (jsonMode) {
+                outputErrorAsJson('PMO_NOT_FOUND', 'PMO not found. Run "prlt pmo init" first.', createMetadata('pr', flags));
+                this.exit(1);
+            }
+            this.error('PMO not found. Run "prlt pmo init" first.');
+        }
+        // Define choices once, use for both JSON and interactive modes
+        const menuChoices = [
+            { name: 'Create PR from current branch', value: 'create' },
+            { name: 'Link existing PR to ticket', value: 'link' },
+            { name: 'View PR status for ticket', value: 'status' },
+            { name: 'Cancel', value: 'cancel' },
+        ];
+        const message = 'Pull Request Operations - What would you like to do?';
+        // In JSON mode, output menu prompt
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, menuChoices), createMetadata('pr', flags));
+            return;
+        }
+        // Show interactive menu (with separator before Cancel)
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message,
+                choices: [
+                    ...menuChoices.slice(0, -1),
+                    new inquirer.Separator('──────────────'),
+                    menuChoices[menuChoices.length - 1],
+                ],
+            }]);
+        if (action === 'cancel') {
+            return;
+        }
+        // Run the selected subcommand
+        switch (action) {
+            case 'create':
+                await this.config.runCommand('pr:create', []);
+                break;
+            case 'link':
+                await this.config.runCommand('pr:link', []);
+                break;
+            case 'status':
+                await this.config.runCommand('pr:status', []);
+                break;
+        }
+    }
+}