@proletariat/cli 0.2.0 → 0.3.0

package/dist/commands/ticket/template/save.js

@@ -0,0 +1,110 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+export default class TicketTemplateSave extends PMOCommand {
+    static description = 'Create a template from an existing ticket';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 "Bug Report Template"',
+        '<%= config.bin %> <%= command.id %> TKT-042 "Feature Request" --description "Standard feature request template"',
+    ];
+    static args = {
+        ticket: Args.string({
+            description: 'Ticket ID to create template from',
+            required: false,
+        }),
+        name: Args.string({
+            description: 'Template name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketTemplateSave);
+        // Get ticket ID - prompt with picker if not provided
+        let ticketId = args.ticket;
+        if (!ticketId) {
+            const projectId = await this.requireProject();
+            const tickets = await this.storage.listTickets(projectId);
+            if (tickets.length === 0) {
+                this.error('No tickets found in this project.\nCreate a ticket first: prlt ticket create');
+            }
+            const { selectedTicket } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedTicket',
+                    message: 'Select a ticket to save as template:',
+                    choices: tickets.slice(0, 20).map(t => ({
+                        name: `${t.id} - ${t.title}`,
+                        value: t.id,
+                    })),
+                }]);
+            ticketId = selectedTicket;
+        }
+        // Verify ticket exists
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            this.error(`Ticket not found: ${ticketId}\nRun 'prlt ticket list' to see available tickets.`);
+        }
+        // Get template name - prompt if not provided
+        let templateName = args.name;
+        if (!templateName) {
+            const { name } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'name',
+                    message: 'Template name:',
+                    default: ticket.category || ticket.title.split(' ')[0],
+                    validate: (input) => input.length > 0 || 'Name is required',
+                }]);
+            templateName = name;
+        }
+        // Get description if not provided
+        let description = flags.description;
+        if (description === undefined) {
+            const { desc } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'desc',
+                    message: 'Description (optional):',
+                }]);
+            description = desc || undefined;
+        }
+        // Create template from ticket
+        const template = await this.storage.createTicketTemplateFromTicket(ticketId, templateName, description);
+        this.log(styles.success(`\nCreated template "${styles.emphasis(template.name)}" from ticket ${ticketId}`));
+        this.log(styles.muted(`  ID: ${template.id}`));
+        if (template.description) {
+            this.log(styles.muted(`  Description: ${template.description}`));
+        }
+        if (template.titlePattern) {
+            this.log(styles.muted(`  Title pattern: ${template.titlePattern}`));
+        }
+        if (template.defaultPriority) {
+            this.log(styles.muted(`  Default priority: ${template.defaultPriority}`));
+        }
+        if (template.defaultCategory) {
+            this.log(styles.muted(`  Default category: ${template.defaultCategory}`));
+        }
+        if (template.defaultStatusId) {
+            this.log(styles.muted(`  Default status: ${template.defaultStatusId}`));
+        }
+        if (template.defaultAssignee) {
+            this.log(styles.muted(`  Default assignee: ${template.defaultAssignee}`));
+        }
+        if (template.defaultOwner) {
+            this.log(styles.muted(`  Default owner: ${template.defaultOwner}`));
+        }
+        if (template.defaultLabels && template.defaultLabels.length > 0) {
+            this.log(styles.muted(`  Default labels: ${template.defaultLabels.join(', ')}`));
+        }
+        if (template.suggestedSubtasks.length > 0) {
+            this.log(styles.muted(`  Subtasks: ${template.suggestedSubtasks.length}`));
+        }
+        this.log('');
+        this.log(styles.muted(`Create ticket from template: prlt ticket template apply ${template.id}`));
+    }
+}

package/dist/commands/ticket/update.d.ts

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TicketUpdate 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>;
+        priority: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        category: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        bulk: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private executeBulk;
+}

package/dist/commands/ticket/update.js

@@ -0,0 +1,325 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
+import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class TicketUpdate extends PMOCommand {
+    static description = 'Update priority/category for ticket(s)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 --priority HIGH',
+        '<%= config.bin %> <%= command.id %> TKT-001 --category bug',
+        '<%= config.bin %> <%= command.id %> --bulk',
+        '<%= config.bin %> <%= command.id %> --bulk --priority HIGH',
+        '<%= 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,
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'Set priority (P0, P1, P2, P3)',
+            options: [...PRIORITIES],
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'Set category (e.g., feature, bug, refactor)',
+        }),
+        bulk: Flags.boolean({
+            char: 'b',
+            description: 'Enable bulk mode to update multiple tickets',
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketUpdate);
+        const projectId = flags.project;
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Get all tickets
+        const allTickets = await this.storage.listTickets(projectId);
+        if (allTickets.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_TICKETS', 'No tickets found.', createMetadata('ticket update', flags));
+                return;
+            }
+            this.log(styles.warning('No tickets found.'));
+            return;
+        }
+        // Bulk mode
+        if (flags.bulk) {
+            await this.executeBulk(allTickets, flags);
+            return;
+        }
+        // Single ticket mode
+        let ticketId = args.ticketId;
+        if (!ticketId) {
+            const selected = await this.selectFromList({
+                message: 'Select ticket to update:',
+                items: allTickets,
+                getName: (t) => `${t.id} - ${t.title} (${t.statusName})`,
+                getValue: (t) => t.id,
+                getCommand: (t) => `prlt ticket update ${t.id} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'ticket update' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            ticketId = selected;
+        }
+        // Get ticket
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            this.error(`Ticket "${ticketId}" not found.`);
+        }
+        // Determine what to update
+        let updatePriority = flags.priority;
+        let updateCategory = flags.category;
+        if (!updatePriority && !updateCategory) {
+            // Ask what to update
+            const { updateType } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'updateType',
+                    message: 'What would you like to update?',
+                    choices: [
+                        { name: 'Priority', value: 'priority' },
+                        { name: 'Category', value: 'category' },
+                        { name: 'Both', value: 'both' },
+                    ],
+                }]);
+            if (updateType === 'priority' || updateType === 'both') {
+                const { priority } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'priority',
+                        message: 'Set priority to:',
+                        choices: [
+                            { name: `(Keep existing: ${ticket.priority || 'none'})`, value: null },
+                            ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                            { name: 'None (clear priority)', value: '' },
+                        ],
+                    }]);
+                if (priority !== null) {
+                    updatePriority = priority;
+                }
+            }
+            if (updateType === 'category' || updateType === 'both') {
+                const { categoryChoice } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'categoryChoice',
+                        message: 'Set category to:',
+                        choices: [
+                            { name: `(Keep existing: ${ticket.category || 'none'})`, value: null },
+                            { name: 'feature', value: 'feature' },
+                            { name: 'bug', value: 'bug' },
+                            { name: 'refactor', value: 'refactor' },
+                            { name: 'docs', value: 'docs' },
+                            { name: 'test', value: 'test' },
+                            { name: 'chore', value: 'chore' },
+                            { name: 'None (clear category)', value: '' },
+                            { name: 'Custom...', value: '__custom__' },
+                        ],
+                    }]);
+                if (categoryChoice === '__custom__') {
+                    const { customCategory } = await inquirer.prompt([{
+                            type: 'input',
+                            name: 'customCategory',
+                            message: 'Enter custom category:',
+                            validate: (input) => input.length > 0 || 'Category is required',
+                        }]);
+                    updateCategory = customCategory;
+                }
+                else if (categoryChoice !== null) {
+                    updateCategory = categoryChoice;
+                }
+            }
+        }
+        // Check if anything to update
+        if (updatePriority === undefined && updateCategory === undefined) {
+            this.log(styles.muted('Nothing to update.'));
+            return;
+        }
+        // Build changes
+        const changes = {};
+        if (updatePriority !== undefined) {
+            changes.priority = updatePriority || undefined;
+        }
+        if (updateCategory !== undefined) {
+            changes.category = updateCategory || undefined;
+        }
+        // Update ticket
+        await this.storage.updateTicket(ticketId, changes);
+        // Auto-export
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        const updates = [];
+        if (updatePriority !== undefined)
+            updates.push(`Priority: ${updatePriority || 'none'}`);
+        if (updateCategory !== undefined)
+            updates.push(`Category: ${updateCategory || 'none'}`);
+        this.log(styles.success(`\n✅ Updated ticket ${styles.emphasis(ticketId)}`));
+        this.log(styles.muted(`   ${updates.join(', ')}`));
+    }
+    async executeBulk(allTickets, flags) {
+        this.log(styles.emphasis('✏️  Update Multiple Tickets\n'));
+        // Select tickets to update
+        const { selectedTickets } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedTickets',
+                message: 'Select tickets to update:',
+                choices: allTickets.map(t => ({
+                    name: `${t.id} - ${t.title}  [P:${t.priority || 'none'} C:${t.category || 'none'}]`,
+                    value: t.id,
+                })),
+            }]);
+        if (selectedTickets.length === 0) {
+            this.log(styles.muted('No tickets selected.'));
+            return;
+        }
+        // Determine what to update
+        let updatePriority = flags.priority;
+        let updateCategory = flags.category;
+        if (!updatePriority && !updateCategory) {
+            // Ask what to update
+            const { updateType } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'updateType',
+                    message: 'What would you like to update?',
+                    choices: [
+                        { name: 'Priority', value: 'priority' },
+                        { name: 'Category', value: 'category' },
+                        { name: 'Both', value: 'both' },
+                    ],
+                }]);
+            if (updateType === 'priority' || updateType === 'both') {
+                const { priority } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'priority',
+                        message: 'Set priority to:',
+                        choices: [
+                            { name: '(Keep existing)', value: null },
+                            ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                            { name: 'None (clear priority)', value: '' },
+                        ],
+                    }]);
+                if (priority !== null) {
+                    updatePriority = priority;
+                }
+            }
+            if (updateType === 'category' || updateType === 'both') {
+                const { categoryChoice } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'categoryChoice',
+                        message: 'Set category to:',
+                        choices: [
+                            { name: '(Keep existing)', value: null },
+                            { name: 'feature', value: 'feature' },
+                            { name: 'bug', value: 'bug' },
+                            { name: 'refactor', value: 'refactor' },
+                            { name: 'docs', value: 'docs' },
+                            { name: 'test', value: 'test' },
+                            { name: 'chore', value: 'chore' },
+                            { name: 'None (clear category)', value: '' },
+                            { name: 'Custom...', value: '__custom__' },
+                        ],
+                    }]);
+                if (categoryChoice === '__custom__') {
+                    const { customCategory } = await inquirer.prompt([{
+                            type: 'input',
+                            name: 'customCategory',
+                            message: 'Enter custom category:',
+                            validate: (input) => input.length > 0 || 'Category is required',
+                        }]);
+                    updateCategory = customCategory;
+                }
+                else if (categoryChoice !== null) {
+                    updateCategory = categoryChoice;
+                }
+            }
+        }
+        // Check if anything to update
+        if (updatePriority === undefined && updateCategory === undefined) {
+            this.log(styles.muted('Nothing to update.'));
+            return;
+        }
+        // Confirmation
+        if (!flags.force) {
+            this.log(styles.primary('\nWill update:'));
+            if (updatePriority !== undefined) {
+                this.log(styles.primary(`  Priority → ${updatePriority || '(clear)'}`));
+            }
+            if (updateCategory !== undefined) {
+                this.log(styles.primary(`  Category → ${updateCategory || '(clear)'}`));
+            }
+            this.log(styles.primary('\nTickets:'));
+            for (const ticketId of selectedTickets) {
+                const ticket = allTickets.find(t => t.id === ticketId);
+                this.log(styles.primary(`  • ${ticketId}: ${ticket?.title}`));
+            }
+            this.log('');
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: 'Continue?',
+                    choices: [
+                        { name: 'No, cancel', value: false },
+                        { name: 'Yes, update tickets', value: true }
+                    ],
+                    default: 0
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Operation cancelled.'));
+                return;
+            }
+        }
+        this.log('');
+        // Update each ticket
+        let successCount = 0;
+        let failCount = 0;
+        for (const ticketId of selectedTickets) {
+            try {
+                const changes = {};
+                if (updatePriority !== undefined) {
+                    changes.priority = updatePriority || undefined;
+                }
+                if (updateCategory !== undefined) {
+                    changes.category = updateCategory || undefined;
+                }
+                await this.storage.updateTicket(ticketId, changes);
+                const updates = [];
+                if (updatePriority !== undefined)
+                    updates.push(`P:${updatePriority || 'none'}`);
+                if (updateCategory !== undefined)
+                    updates.push(`C:${updateCategory || 'none'}`);
+                this.log(styles.success(`${ticketId}: ${updates.join(', ')}`));
+                successCount++;
+            }
+            catch (error) {
+                this.log(styles.error(`Failed to update ${ticketId}: ${error instanceof Error ? error.message : String(error)}`));
+                failCount++;
+            }
+        }
+        // Auto-export to kanban.md
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        // Summary
+        this.log('');
+        if (successCount > 0) {
+            this.log(styles.success(`Updated ${successCount} ticket(s)`));
+        }
+        if (failCount > 0) {
+            this.log(styles.error(`Failed to update ${failCount} ticket(s)`));
+        }
+    }
+}

package/dist/commands/ticket/view.d.ts

@@ -0,0 +1,13 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TicketView 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>;
+    };
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/ticket/view.js

@@ -0,0 +1,80 @@
+import { Args, Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class TicketView extends PMOCommand {
+    static description = 'View detailed ticket information';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TICK-001',
+        '<%= config.bin %> <%= command.id %>  # Interactive mode',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID to view - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TicketView);
+        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('ticket view', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get ticketId - prompt if not provided
+        let ticketId = args.ticketId;
+        if (!ticketId) {
+            // Get all tickets for selection
+            const allTickets = await this.storage.listTickets(projectId);
+            if (allTickets.length === 0) {
+                return handleError('NO_TICKETS', 'No tickets found. Create a ticket first with "prlt ticket create".');
+            }
+            // Use helper for ticket selection (handles JSON mode automatically)
+            const selected = await this.selectFromList({
+                message: 'Select ticket to view:',
+                items: allTickets,
+                getName: (t) => `${t.id} - ${t.title} (${t.statusName})`,
+                getValue: (t) => t.id,
+                getCommand: (t) => `prlt ticket view ${t.id} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'ticket view' } : null,
+            });
+            if (!selected) {
+                return; // Cancelled or JSON mode (already exited)
+            }
+            ticketId = selected;
+        }
+        // Get ticket
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            this.error(`Ticket "${ticketId}" not found.`);
+        }
+        const board = await this.storage.getBoard(ticket.projectId);
+        // Display ticket details
+        this.log(`\n${styles.header('📄 Ticket')} ${styles.emphasis(ticket.id)}\n`);
+        this.log(`${styles.header('Title:')}       ${ticket.title}`);
+        this.log(`${styles.header('Project:')}     ${board.name}`);
+        this.log(`${styles.header('Status:')}      ${ticket.statusName}`);
+        this.log(`${styles.header('Priority:')}    ${ticket.priority || 'none'}`);
+        this.log(`${styles.header('Category:')}    ${ticket.category || 'none'}`);
+        this.log(`${styles.header('Created:')}     ${ticket.createdAt ? new Date(ticket.createdAt).toLocaleString() : 'unknown'}`);
+        this.log(`${styles.header('Updated:')}     ${ticket.updatedAt ? new Date(ticket.updatedAt).toLocaleString() : 'unknown'}`);
+        if (ticket.description) {
+            this.log(`\n${styles.header('Description:')}`);
+            this.log(`  ${ticket.description.split('\n').join('\n  ')}`);
+        }
+        this.log('');
+    }
+}

package/dist/commands/whoami.d.ts

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

package/dist/commands/whoami.js

@@ -0,0 +1,103 @@
+import { Command } from '@oclif/core';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+import { colors } from '../lib/colors.js';
+export default class Whoami extends Command {
+    static description = 'Show current agent/environment context';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        const isDevcontainer = process.env.DEVCONTAINER === 'true';
+        const agentName = this.detectAgentName();
+        const repoName = this.detectRepoName();
+        const branch = this.getCurrentBranch();
+        const hqPath = process.env.PRLT_HQ_PATH;
+        this.log('');
+        this.log(colors.primary('🔍 Proletariat Context'));
+        this.log('');
+        // Agent info
+        if (agentName) {
+            this.log(`  Agent:       ${colors.primary(agentName)}`);
+        }
+        else {
+            this.log(`  Agent:       ${colors.textMuted('(not detected)')}`);
+        }
+        // Repository info
+        if (repoName) {
+            this.log(`  Repository:  ${colors.text(repoName)}`);
+        }
+        // Branch info
+        if (branch) {
+            this.log(`  Branch:      ${colors.text(branch)}`);
+        }
+        // Environment
+        this.log('');
+        this.log(`  Environment: ${isDevcontainer ? colors.primary('devcontainer') : colors.text('host')}`);
+        this.log(`  Working dir: ${colors.textMuted(process.cwd())}`);
+        if (hqPath) {
+            this.log(`  HQ path:     ${colors.textMuted(hqPath)}`);
+        }
+        // Show PMO path if available
+        const pmoPath = process.env.PRLT_PMO_PATH;
+        if (pmoPath) {
+            this.log(`  PMO path:    ${colors.textMuted(pmoPath)}`);
+        }
+        this.log('');
+    }
+    detectAgentName() {
+        // Check environment variable first (set in devcontainer)
+        if (process.env.PRLT_AGENT_NAME) {
+            return process.env.PRLT_AGENT_NAME;
+        }
+        // Try to detect from directory structure
+        // Pattern: /workspace/proletariat-{agentName} or agents/staff/{agentName}
+        const cwd = process.cwd();
+        // Devcontainer pattern: /workspace/proletariat-{agent}
+        const workspaceMatch = cwd.match(/\/workspace\/[^/]+-(\w+)/);
+        if (workspaceMatch) {
+            return workspaceMatch[1];
+        }
+        // Host pattern: agents/staff/{agent}
+        const staffMatch = cwd.match(/agents\/staff\/(\w+)/);
+        if (staffMatch) {
+            return staffMatch[1];
+        }
+        // Try git branch pattern: agent-{name}
+        try {
+            const branch = execSync('git branch --show-current', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+            const agentBranchMatch = branch.match(/^agent-(\w+)$/);
+            if (agentBranchMatch) {
+                return agentBranchMatch[1];
+            }
+        }
+        catch {
+            // Ignore git errors
+        }
+        return null;
+    }
+    detectRepoName() {
+        // Try to get repo name from directory or git remote
+        try {
+            const remote = execSync('git remote get-url origin', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+            const match = remote.match(/\/([^/]+?)(?:\.git)?$/);
+            if (match) {
+                return match[1];
+            }
+        }
+        catch {
+            // Ignore git errors
+        }
+        // Fallback to directory name
+        const cwd = process.cwd();
+        return path.basename(cwd);
+    }
+    getCurrentBranch() {
+        try {
+            return execSync('git branch --show-current', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        }
+        catch {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkComplete 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>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+}