@proletariat/cli 0.2.0 → 0.3.0

package/dist/commands/docker/sync.js

@@ -0,0 +1,112 @@
+import { Command } from '@oclif/core';
+import { execSync } from 'child_process';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ContainerStorage } from '../../lib/execution/storage.js';
+import { isDockerRunning } from '../../lib/execution/runners.js';
+export default class DockerSync extends Command {
+    static description = 'Sync container status from Docker into the database';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        if (!isDockerRunning()) {
+            this.error('Docker is not running. Start Docker Desktop or the Docker daemon first.');
+        }
+        // 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');
+        let db;
+        try {
+            db = new Database(dbPath);
+        }
+        catch {
+            this.error('Could not open workspace database.');
+        }
+        try {
+            const containerStorage = new ContainerStorage(db);
+            // Get devcontainers from Docker
+            const dockerContainers = this.getDockerContainers();
+            this.log(`\n${styles.header('Syncing Containers')}`);
+            this.log(styles.muted(`Found ${dockerContainers.length} devcontainers in Docker\n`));
+            // Add agent name from image (only used for new containers)
+            const containersWithAgent = dockerContainers.map(c => ({
+                ...c,
+                agentName: this.extractAgentFromImage(c.image),
+            }));
+            // Sync with database
+            const result = containerStorage.syncFromDocker(containersWithAgent);
+            this.log(styles.success('✓ Sync complete'));
+            this.log(styles.muted(`  Added: ${result.added}`));
+            this.log(styles.muted(`  Updated: ${result.updated}`));
+            this.log(styles.muted(`  Marked removed: ${result.removed}\n`));
+            // Show current containers
+            const containers = containerStorage.listContainers({ limit: 20 });
+            if (containers.length > 0) {
+                this.log(styles.subheader('Tracked Containers:'));
+                this.log(styles.muted('  ' +
+                    'ID'.padEnd(18) +
+                    'Agent'.padEnd(15) +
+                    'Status'.padEnd(12) +
+                    'Docker ID'));
+                this.log(styles.muted('  ' + '-'.repeat(65)));
+                for (const container of containers) {
+                    const statusColor = container.status === 'running' ? styles.success :
+                        container.status === 'exited' ? styles.muted :
+                            container.status === 'removed' ? styles.error : styles.warning;
+                    this.log('  ' +
+                        container.id.padEnd(18) +
+                        container.agentName.padEnd(15) +
+                        statusColor(container.status.padEnd(12)) +
+                        styles.muted(container.dockerId.substring(0, 12)));
+                }
+                this.log('');
+            }
+            else {
+                this.log('');
+            }
+            db.close();
+        }
+        catch (error) {
+            db.close();
+            throw error;
+        }
+    }
+    /**
+     * Get raw container info from Docker
+     */
+    getDockerContainers() {
+        try {
+            const output = execSync('docker ps -a --format "{{.ID}}|{{.Names}}|{{.Image}}|{{.Status}}"', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            if (!output)
+                return [];
+            return output.split('\n').filter(Boolean).map(line => {
+                const [id, name, image, status] = line.split('|');
+                return { id, name, image, status };
+            }).filter(c => c.image.startsWith('vsc-')); // Only devcontainers
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Extract agent name from devcontainer image name.
+     * Only used for initial sync - DB is source of truth after that.
+     */
+    extractAgentFromImage(image) {
+        const match = image.match(/^vsc-([^-]+)-/);
+        return match ? match[1] : 'unknown';
+    }
+}

package/dist/commands/epic/activate.d.ts

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

package/dist/commands/epic/activate.js

@@ -0,0 +1,118 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { moveEpicFile, getRelativeEpicPath } from '../../lib/pmo/epic-files.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class EpicActivate extends PMOCommand {
+    static description = 'Activate a draft or archived epic';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> EPIC-004',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Epic ID',
+            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(EpicActivate);
+        const projectId = await this.requireProject();
+        // 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('epic activate', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        let epicId = args.id;
+        // If no ID provided, prompt for selection (show only non-active epics)
+        if (!epicId) {
+            const epics = await this.storage.listEpics(projectId);
+            const activatable = epics.filter(e => e.status !== 'active');
+            if (activatable.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_EPICS_TO_ACTIVATE', 'No epics available to activate.', createMetadata('epic activate', flags));
+                    return;
+                }
+                this.log(styles.muted('\nNo epics available to activate.'));
+                return;
+            }
+            const selected = await this.selectFromList({
+                message: 'Select epic to activate:',
+                items: activatable,
+                getName: (e) => `${e.id} ${e.title} (${e.status})`,
+                getValue: (e) => e.id,
+                getCommand: (e) => `prlt epic activate ${e.id} --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'epic activate' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            epicId = selected;
+        }
+        const epic = await this.storage.getEpic(epicId);
+        if (!epic) {
+            return handleError('EPIC_NOT_FOUND', `Epic not found: ${epicId}`);
+        }
+        if (epic.status === 'active') {
+            this.log(styles.muted(`Epic ${epicId} is already active.`));
+            return;
+        }
+        // Warn if reactivating a complete epic
+        if (epic.status === 'complete') {
+            const tickets = await this.storage.getTicketsForEpic(projectId, epicId);
+            const doneTickets = tickets.filter((t) => t.status === 'done').length;
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                const confirmChoices = [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ];
+                outputPromptAsJson(buildPromptConfig('list', 'confirm', `This epic was previously completed (${doneTickets}/${tickets.length} tickets done). Reactivate this epic?`, confirmChoices), createMetadata('epic activate', flags));
+                return;
+            }
+            this.log(styles.warning(`\n⚠️  This epic was previously completed (${doneTickets}/${tickets.length} tickets done)`));
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: 'Reactivate this epic?',
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes', value: true },
+                    ],
+                    default: false,
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        this.log(`\nActivating: ${epicId} "${epic.title}"`);
+        this.log(`Current status: ${epic.status}`);
+        const previousStatus = epic.status;
+        // Move the epic file to active status directory
+        const moveResult = moveEpicFile(this.pmoPath, epicId, previousStatus, 'active', projectId);
+        await this.storage.updateEpic(epicId, { status: 'active' });
+        this.log(styles.success(`\n✅ Activated epic ${styles.emphasis(epicId)} "${epic.title}"`));
+        this.log(styles.muted(`   Status: ${previousStatus} → active`));
+        if (moveResult) {
+            const relativePath = getRelativeEpicPath(this.pmoPath, epicId, 'active', projectId);
+            this.log(styles.muted(`   File: ${relativePath}`));
+        }
+        this.log(styles.muted('\nNext steps:'));
+        this.log(styles.muted(`  prlt epic view ${epicId}`));
+        this.log(styles.muted(`  prlt ticket create --epic ${epicId} "First task"`));
+    }
+}

package/dist/commands/epic/archive.d.ts

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

package/dist/commands/epic/archive.js

@@ -0,0 +1,132 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { moveEpicFile, getRelativeEpicPath } from '../../lib/pmo/epic-files.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class EpicArchive extends PMOCommand {
+    static description = 'Archive a completed epic';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> EPIC-002',
+        '<%= config.bin %> <%= command.id %> --force',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Epic ID',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip ticket completion check',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(EpicArchive);
+        const projectId = await this.requireProject();
+        // 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('epic archive', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        let epicId = args.id;
+        // If no ID provided, prompt for selection (show only non-complete epics)
+        if (!epicId) {
+            const epics = await this.storage.listEpics(projectId);
+            const archivable = epics.filter(e => e.status !== 'complete' && e.status !== 'dropped');
+            if (archivable.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_EPICS_TO_ARCHIVE', 'No epics available to archive.', createMetadata('epic archive', flags));
+                    return;
+                }
+                this.log(styles.muted('\nNo epics available to archive.'));
+                return;
+            }
+            // Get ticket counts
+            const choices = await Promise.all(archivable.map(async (e) => {
+                const tickets = await this.storage.getTicketsForEpic(projectId, e.id);
+                const done = tickets.filter((t) => t.status === 'done').length;
+                const complete = done === tickets.length && tickets.length > 0;
+                return {
+                    name: `${e.id} ${e.title} (${e.status}) [${done}/${tickets.length} tickets complete]${complete ? ' ✅' : ''}`,
+                    value: e.id,
+                };
+            }));
+            // In JSON mode, output epic selection prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select epic to archive:', choices), createMetadata('epic archive', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select epic to archive:',
+                    choices,
+                }]);
+            epicId = selected;
+        }
+        const epic = await this.storage.getEpic(epicId);
+        if (!epic) {
+            return handleError('EPIC_NOT_FOUND', `Epic not found: ${epicId}`);
+        }
+        if (epic.status === 'complete') {
+            this.log(styles.muted(`Epic ${epicId} is already archived.`));
+            return;
+        }
+        // Check ticket completion
+        const tickets = await this.storage.getTicketsForEpic(projectId, epicId);
+        const doneTickets = tickets.filter((t) => t.status === 'done').length;
+        const allComplete = doneTickets === tickets.length;
+        if (!allComplete && !flags.force) {
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                const confirmChoices = [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ];
+                outputPromptAsJson(buildPromptConfig('list', 'confirm', `Not all tickets are complete (${doneTickets}/${tickets.length} done). Continue archiving anyway?`, confirmChoices), createMetadata('epic archive', flags));
+                return;
+            }
+            this.log(styles.warning(`\n⚠️  Not all tickets are complete (${doneTickets}/${tickets.length} done)`));
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: 'Continue archiving anyway?',
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes', value: true },
+                    ],
+                    default: false,
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        this.log(`\nArchiving: ${epicId} "${epic.title}"`);
+        this.log(`Status: ${doneTickets}/${tickets.length} tickets complete${allComplete ? ' ✅' : ''}`);
+        // Move the epic file to complete status directory
+        const moveResult = moveEpicFile(this.pmoPath, epicId, epic.status, 'complete', projectId);
+        await this.storage.updateEpic(epicId, { status: 'complete' });
+        this.log(styles.success(`\n✅ Archived epic ${styles.emphasis(epicId)} "${epic.title}"`));
+        this.log(styles.muted(`   Status: ${epic.status} → complete`));
+        if (moveResult) {
+            const relativePath = getRelativeEpicPath(this.pmoPath, epicId, 'complete', projectId);
+            this.log(styles.muted(`   File: ${relativePath}`));
+        }
+        this.log(styles.muted('\nView archived epics:'));
+        this.log(styles.muted('  prlt epic list --status complete'));
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class EpicCreate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        title: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        spec: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private promptEpicData;
+}

package/dist/commands/epic/create.js

@@ -0,0 +1,137 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { createEpicFile, getRelativeEpicPath } from '../../lib/pmo/epic-files.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class EpicCreate extends PMOCommand {
+    static description = 'Create a new epic';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --title "User Authentication System"',
+        '<%= config.bin %> <%= command.id %> -t "API Design" --status draft',
+        '<%= config.bin %> <%= command.id %> -t "Implement Auth" --spec SPEC-001',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        title: Flags.string({
+            char: 't',
+            description: 'Epic title',
+        }),
+        status: Flags.string({
+            char: 's',
+            description: 'Initial status',
+            options: ['active', 'draft'],
+            default: 'active',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Epic description',
+        }),
+        spec: Flags.string({
+            description: 'Link to spec ID (the design spec that describes this epic)',
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(EpicCreate);
+        const projectId = await this.requireProject();
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Build choices once, use for both JSON and interactive modes
+        const statusChoices = [
+            { name: 'Active (currently working on)', value: 'active' },
+            { name: 'Draft (planning phase)', value: 'draft' },
+        ];
+        // Get epic data
+        let epicData;
+        if (!flags.title) {
+            // Get specs once, use for both modes
+            const specs = await this.storage.listSpecs();
+            const specChoices = [
+                { name: 'None (no spec linked)', value: '' },
+                ...specs.map(s => ({
+                    name: `${s.id} - ${s.title}`,
+                    value: s.id,
+                })),
+            ];
+            // Define fields once - single source of truth for both JSON and interactive modes
+            const fields = [
+                { type: 'input', name: 'title', message: 'Epic title:', default: flags.title },
+                { type: 'list', name: 'status', message: 'Initial status:', choices: statusChoices, default: flags.status || 'active' },
+                { type: 'input', name: 'description', message: 'Description (optional):', default: flags.description },
+            ];
+            if (specs.length > 0) {
+                fields.push({
+                    type: 'list', name: 'specId', message: 'Link to spec (design document):',
+                    choices: specChoices, default: flags.spec || ''
+                });
+            }
+            // In JSON mode, output form prompt for epic creation
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('epic create', flags));
+            }
+            epicData = await this.promptEpicData(fields, specChoices.length > 1);
+        }
+        else {
+            epicData = {
+                title: flags.title,
+                status: (flags.status || 'active'),
+                description: flags.description,
+                specId: flags.spec,
+            };
+        }
+        // Validate spec exists if provided
+        if (epicData.specId) {
+            const spec = await this.storage.getSpec(epicData.specId);
+            if (!spec) {
+                this.error(`Spec not found: ${epicData.specId}`);
+            }
+        }
+        const epic = await this.storage.createEpic(projectId, {
+            title: epicData.title,
+            status: epicData.status,
+            description: epicData.description,
+            specId: epicData.specId,
+        });
+        // Create markdown file for the epic
+        const filePath = createEpicFile(this.pmoPath, epic, projectId);
+        const relativePath = getRelativeEpicPath(this.pmoPath, epic.id, epic.status, projectId);
+        // Update epic with file path
+        await this.storage.updateEpic(epic.id, { filePath });
+        const projectName = await this.getProjectName(projectId);
+        this.log(styles.success(`\n✅ Created epic ${styles.emphasis(epic.id)} "${epic.title}"`));
+        this.log(styles.muted(`   Project: ${projectName}`));
+        this.log(styles.muted(`   Status: ${epic.status}`));
+        if (epic.specId) {
+            this.log(styles.muted(`   Spec: ${epic.specId}`));
+        }
+        this.log(styles.muted(`   File: ${relativePath}`));
+        this.log('');
+        this.log(styles.muted('Next steps:'));
+        this.log(styles.muted(`  1. Edit the epic file to add details:`));
+        this.log(styles.muted(`     ${relativePath}`));
+        this.log(styles.muted(`  2. Create tickets linked to this epic:`));
+        this.log(styles.muted(`     prlt ticket create --epic ${epic.id} "Design auth flow"`));
+        this.log(styles.muted(`  3. View progress: prlt epic progress ${epic.id}`));
+    }
+    async promptEpicData(fields, hasSpecs) {
+        // Build inquirer prompts from fields, adding validators and conditionals
+        const answers = await inquirer.prompt(fields.map(field => ({
+            ...field,
+            validate: field.name === 'title'
+                ? ((input) => input.length > 0 || 'Title is required')
+                : undefined,
+            when: field.name === 'specId' ? () => hasSpecs : undefined,
+        })));
+        return {
+            title: answers.title,
+            status: answers.status,
+            description: answers.description || undefined,
+            specId: answers.specId || undefined,
+        };
+    }
+}

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

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

@@ -0,0 +1,88 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, } from '../../lib/prompt-json.js';
+export default class Epic extends PMOCommand {
+    static description = 'Interactive menu for epic operations';
+    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() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(Epic);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        // Each choice includes the full command for AI agents to execute
+        const menuChoices = [
+            { id: 'create', name: 'Create new epic', command: 'prlt epic create --json' },
+            { id: 'list', name: 'List all epics', command: 'prlt epic list --format json' },
+            { id: 'view', name: 'View epic', command: 'prlt epic view --json' },
+            { id: 'progress', name: 'Show progress', command: 'prlt epic progress --json' },
+            { id: 'ticket', name: 'Assign tickets to epic', command: 'prlt epic ticket --json' },
+            { id: 'spec', name: 'Assign spec to epic', command: 'prlt epic spec --json' },
+            { id: 'link', name: 'Manage dependencies', command: 'prlt epic link --json' },
+            { id: 'archive', name: 'Archive epic (complete)', command: 'prlt epic archive --json' },
+            { id: 'activate', name: 'Activate epic', command: 'prlt epic activate --json' },
+            { id: 'move', name: 'Reorder epic', command: 'prlt epic move --json' },
+            { id: 'project', name: 'Move to different project', command: 'prlt epic project --json' },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'Epic 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: 'epic' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            return;
+        }
+        // Run the selected subcommand
+        switch (action) {
+            case 'create':
+                await this.config.runCommand('epic:create', []);
+                break;
+            case 'list':
+                await this.config.runCommand('epic:list', []);
+                break;
+            case 'view':
+                await this.config.runCommand('epic:view', []);
+                break;
+            case 'progress':
+                await this.config.runCommand('epic:progress', []);
+                break;
+            case 'ticket':
+                await this.config.runCommand('epic:ticket', []);
+                break;
+            case 'spec':
+                await this.config.runCommand('epic:spec', []);
+                break;
+            case 'link':
+                await this.config.runCommand('epic:link', []);
+                break;
+            case 'archive':
+                await this.config.runCommand('epic:archive', []);
+                break;
+            case 'activate':
+                await this.config.runCommand('epic:activate', []);
+                break;
+            case 'move':
+                await this.config.runCommand('epic:move', []);
+                break;
+            case 'project':
+                await this.config.runCommand('epic:project', []);
+                break;
+        }
+    }
+}

package/dist/commands/epic/link/block.d.ts

@@ -0,0 +1,14 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class EpicLinkBlock extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        blocker: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<void>;
+}