@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/epic/link/block.js

@@ -0,0 +1,79 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class EpicLinkBlock extends PMOCommand {
+    static description = 'Add a blocking dependency (epic is blocked by another)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> EPIC-001 EPIC-002  # EPIC-001 is blocked by EPIC-002',
+    ];
+    static args = {
+        id: Args.string({ description: 'Epic ID that will be blocked', required: true }),
+        blocker: Args.string({ description: 'Epic ID that blocks this epic', required: false }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        project: Flags.string({ char: 'P', description: 'Project ID' }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(EpicLinkBlock);
+        // 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 link block', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const epic = await this.storage.getEpic(args.id);
+        if (!epic)
+            return handleError('EPIC_NOT_FOUND', `Epic not found: ${args.id}`);
+        const projectId = epic.projectId;
+        let blockerId = args.blocker;
+        if (!blockerId) {
+            const allEpics = await this.storage.listEpics(projectId);
+            const otherEpics = allEpics.filter(e => e.id !== args.id);
+            if (otherEpics.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_OTHER_EPICS', 'No other epics.', createMetadata('epic link block', flags));
+                    return;
+                }
+                this.log(styles.muted('\nNo other epics.'));
+                return;
+            }
+            // In JSON mode, output blocker selection prompt
+            if (jsonMode) {
+                const epicChoices = otherEpics.map(e => ({ name: `${e.id} - ${e.title} (${e.status})`, value: e.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'blocker', `Select epic that blocks ${args.id}:`, epicChoices), createMetadata('epic link block', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list', name: 'selected', message: `Select epic that blocks ${args.id}:`,
+                    choices: otherEpics.map(e => ({ name: `${e.id} - ${e.title} (${e.status})`, value: e.id })),
+                }]);
+            blockerId = selected;
+        }
+        const blockerEpic = await this.storage.getEpic(blockerId);
+        if (!blockerEpic)
+            return handleError('BLOCKER_EPIC_NOT_FOUND', `Epic not found: ${blockerId}`);
+        try {
+            await this.storage.createEpicDependency(args.id, blockerId, 'blocks');
+            await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+            this.log(styles.success(`\n✅ ${styles.emphasis(args.id)} is blocked by ${styles.emphasis(blockerId)}`));
+            this.log(styles.muted(`   ${epic.title} blocked by: ${blockerEpic.title}`));
+        }
+        catch (error) {
+            if (error instanceof Error && (error.message.includes('already exists') || error.message.includes('self-dependency'))) {
+                this.error(error.message.includes('already exists') ? 'Dependency already exists' : 'Cannot create self-dependency');
+            }
+            throw error;
+        }
+    }
+}

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

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

package/dist/commands/epic/link/duplicates.js

@@ -0,0 +1,66 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class EpicLinkDuplicates extends PMOCommand {
+    static description = 'Mark an epic as duplicate of another';
+    static examples = ['<%= config.bin %> <%= command.id %> EPIC-001 EPIC-002'];
+    static args = {
+        id: Args.string({ description: 'Duplicate epic ID', required: true }),
+        original: Args.string({ description: 'Original epic ID', required: false }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        project: Flags.string({ char: 'P', description: 'Project ID' }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(EpicLinkDuplicates);
+        // 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 link duplicates', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const epic = await this.storage.getEpic(args.id);
+        if (!epic)
+            return handleError('EPIC_NOT_FOUND', `Epic not found: ${args.id}`);
+        const projectId = epic.projectId;
+        let originalId = args.original;
+        if (!originalId) {
+            const allEpics = await this.storage.listEpics(projectId);
+            const otherEpics = allEpics.filter(e => e.id !== args.id);
+            if (otherEpics.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_OTHER_EPICS', 'No other epics.', createMetadata('epic link duplicates', flags));
+                    return;
+                }
+                this.log(styles.muted('\nNo other epics.'));
+                return;
+            }
+            // In JSON mode, output original epic selection prompt
+            if (jsonMode) {
+                const epicChoices = otherEpics.map(e => ({ name: `${e.id} - ${e.title}`, value: e.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'original', `Select the original epic (${args.id} is a duplicate of):`, epicChoices), createMetadata('epic link duplicates', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{ type: 'list', name: 'selected', message: `Select the original epic (${args.id} is a duplicate of):`,
+                    choices: otherEpics.map(e => ({ name: `${e.id} - ${e.title}`, value: e.id })) }]);
+            originalId = selected;
+        }
+        const originalEpic = await this.storage.getEpic(originalId);
+        if (!originalEpic)
+            return handleError('ORIGINAL_EPIC_NOT_FOUND', `Epic not found: ${originalId}`);
+        await this.storage.createEpicDependency(args.id, originalId, 'duplicates');
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\n✅ ${styles.emphasis(args.id)} duplicates ${styles.emphasis(originalId)}`));
+    }
+}

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

@@ -0,0 +1,19 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class EpicLink extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: 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>;
+        blocks: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        relates: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        duplicates: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<void>;
+    private addDependency;
+    private viewDependencies;
+}

package/dist/commands/epic/link/index.js

@@ -0,0 +1,242 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class EpicLink extends PMOCommand {
+    static description = 'Manage epic dependencies (links)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> EPIC-001                     # List dependencies',
+        '<%= config.bin %> <%= command.id %> EPIC-001 --blocks EPIC-002   # EPIC-001 is blocked by EPIC-002',
+        '<%= config.bin %> <%= command.id %> EPIC-001 --relates EPIC-002  # EPIC-001 relates to EPIC-002',
+        '<%= config.bin %> <%= command.id %> EPIC-001 --duplicates EPIC-002',
+        '<%= config.bin %> <%= command.id %> EPIC-001 --all               # Show all links',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Epic ID',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        project: Flags.string({
+            char: 'P',
+            description: 'Project ID (default: "default")',
+        }),
+        blocks: Flags.string({
+            char: 'b',
+            description: 'Add blocking dependency: this epic is blocked by TARGET',
+        }),
+        relates: Flags.string({
+            char: 'r',
+            description: 'Add relates_to dependency',
+        }),
+        duplicates: Flags.string({
+            char: 'd',
+            description: 'Add duplicates dependency',
+        }),
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Show all dependencies (blockers and blocking)',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(EpicLink);
+        // 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 link', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const projectId = await this.requireProject();
+        let epicId = args.id;
+        if (!epicId) {
+            const epics = await this.storage.listEpics(projectId);
+            if (epics.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_EPICS', 'No epics found.', createMetadata('epic link', flags));
+                    return;
+                }
+                this.log(styles.muted('\nNo epics found.'));
+                return;
+            }
+            // In JSON mode, output epic selection prompt
+            if (jsonMode) {
+                const epicChoices = epics.map(e => ({ name: `${e.id} - ${e.title}`, value: e.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select epic to manage dependencies:', epicChoices), createMetadata('epic link', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select epic to manage dependencies:',
+                    choices: epics.map(e => ({ name: `${e.id} - ${e.title}`, value: e.id })),
+                }]);
+            epicId = selected;
+        }
+        const epic = await this.storage.getEpic(epicId);
+        if (!epic) {
+            return handleError('EPIC_NOT_FOUND', `Epic not found: ${epicId}`);
+        }
+        // If a dependency flag is provided, add the dependency directly
+        if (flags.blocks || flags.relates || flags.duplicates) {
+            const targetId = flags.blocks || flags.relates || flags.duplicates;
+            const dependencyType = flags.blocks ? 'blocks' :
+                flags.relates ? 'relates_to' : 'duplicates';
+            await this.addDependency(epicId, targetId, dependencyType, epic.title);
+            return;
+        }
+        // Interactive mode: show menu in a loop
+        let continueLoop = true;
+        while (continueLoop) {
+            const allEpics = await this.storage.listEpics(projectId);
+            const otherEpics = allEpics.filter(e => e.id !== epicId);
+            const { action } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'action',
+                    message: `Dependencies for ${epic.id}:`,
+                    choices: [
+                        { name: 'View dependencies', value: 'view' },
+                        { name: 'Add blocking dependency (blocked by...)', value: 'blocks' },
+                        { name: 'Add relates_to dependency', value: 'relates_to' },
+                        { name: 'Add duplicates dependency', value: 'duplicates' },
+                        new inquirer.Separator(),
+                        { name: 'Remove dependency', value: 'remove' },
+                        { name: 'Done', value: 'done' },
+                    ],
+                }]);
+            if (action === 'done') {
+                continueLoop = false;
+                continue;
+            }
+            if (action === 'view') {
+                await this.viewDependencies(epicId, epic, flags.all);
+                continue;
+            }
+            if (action === 'remove') {
+                const dependencies = await this.storage.listEpicDependencies(epicId);
+                if (dependencies.length === 0) {
+                    this.log(styles.muted('\nNo dependencies to remove.'));
+                    continue;
+                }
+                const choices = await Promise.all(dependencies.map(async (dep) => {
+                    const depEpic = await this.storage.getEpic(dep.dependsOnEpicId);
+                    return {
+                        name: `${dep.dependsOnEpicId} - ${depEpic?.title || 'Unknown'} (${dep.dependencyType})`,
+                        value: { targetId: dep.dependsOnEpicId, type: dep.dependencyType }
+                    };
+                }));
+                const { selected } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selected',
+                        message: 'Select dependency to remove:',
+                        choices,
+                    }]);
+                await this.storage.deleteEpicDependency(epicId, selected.targetId, selected.type);
+                await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+                this.log(styles.success(`\n✅ Removed dependency: ${epicId} → ${selected.targetId}`));
+                continue;
+            }
+            // Add dependency
+            if (otherEpics.length === 0) {
+                this.log(styles.muted('\nNo other epics to link to.'));
+                continue;
+            }
+            const { targetId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'targetId',
+                    message: `Select epic that ${epicId} ${action === 'blocks' ? 'is blocked by' : action === 'relates_to' ? 'relates to' : 'duplicates'}:`,
+                    choices: otherEpics.map(e => ({ name: `${e.id} - ${e.title}`, value: e.id })),
+                }]);
+            await this.addDependency(epicId, targetId, action, epic.title);
+        }
+    }
+    async addDependency(epicId, targetId, dependencyType, epicTitle) {
+        const targetEpic = await this.storage.getEpic(targetId);
+        if (!targetEpic) {
+            this.error(`Epic not found: ${targetId}`);
+        }
+        try {
+            await this.storage.createEpicDependency(epicId, targetId, dependencyType);
+            await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+            const typeLabel = dependencyType === 'blocks' ? 'is blocked by' :
+                dependencyType === 'relates_to' ? 'relates to' : 'duplicates';
+            this.log(styles.success(`\n✅ ${styles.emphasis(epicId)} ${typeLabel} ${styles.emphasis(targetId)}`));
+            this.log(styles.muted(`   ${epicTitle}`));
+            this.log(styles.muted(`   ${typeLabel} ${targetEpic.title}`));
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('already exists')) {
+                    this.error('Dependency already exists');
+                }
+                if (error.message.includes('self-dependency')) {
+                    this.error('Cannot create self-dependency');
+                }
+            }
+            throw error;
+        }
+    }
+    async viewDependencies(epicId, epic, showAll) {
+        const dependencies = await this.storage.listEpicDependencies(epicId);
+        const isBlocked = await this.storage.isEpicBlocked(epicId);
+        this.log(`\n${styles.emphasis(epic.id)}: ${epic.title}`);
+        if (isBlocked) {
+            this.log(styles.warning('  Status: BLOCKED'));
+        }
+        const blockers = dependencies.filter(d => d.dependencyType === 'blocks');
+        if (blockers.length > 0) {
+            this.log(styles.muted('\n  Blocked by:'));
+            for (const dep of blockers) {
+                const blockerEpic = await this.storage.getEpic(dep.dependsOnEpicId);
+                if (blockerEpic) {
+                    const status = blockerEpic.status === 'complete' ? styles.success('complete') : styles.warning(blockerEpic.status);
+                    this.log(`    - ${blockerEpic.id}: ${blockerEpic.title} (${status})`);
+                }
+            }
+        }
+        const otherDeps = dependencies.filter(d => d.dependencyType !== 'blocks');
+        if (otherDeps.length > 0) {
+            this.log(styles.muted('\n  Related:'));
+            for (const dep of otherDeps) {
+                const relatedEpic = await this.storage.getEpic(dep.dependsOnEpicId);
+                if (relatedEpic) {
+                    this.log(`    - ${dep.dependencyType}: ${relatedEpic.id} - ${relatedEpic.title}`);
+                }
+            }
+        }
+        if (showAll) {
+            const allEpics = await this.storage.listEpics(epic.projectId);
+            const blocking = [];
+            for (const otherEpic of allEpics) {
+                if (otherEpic.id === epicId)
+                    continue;
+                const otherDeps = await this.storage.listEpicDependencies(otherEpic.id);
+                const blockingDep = otherDeps.find(d => d.dependsOnEpicId === epicId);
+                if (blockingDep) {
+                    blocking.push({ epic: otherEpic, type: blockingDep.dependencyType });
+                }
+            }
+            if (blocking.length > 0) {
+                this.log(styles.muted('\n  Blocking:'));
+                for (const { epic: blockedEpic, type } of blocking) {
+                    this.log(`    - ${blockedEpic.id}: ${blockedEpic.title} (${type})`);
+                }
+            }
+        }
+        if (dependencies.length === 0) {
+            this.log(styles.muted('\n  No dependencies.'));
+        }
+        this.log('');
+    }
+}

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

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

package/dist/commands/epic/link/relates.js

@@ -0,0 +1,66 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class EpicLinkRelates extends PMOCommand {
+    static description = 'Add a relates_to dependency (informational link)';
+    static examples = ['<%= config.bin %> <%= command.id %> EPIC-001 EPIC-002'];
+    static args = {
+        id: Args.string({ description: 'Epic ID', required: true }),
+        target: Args.string({ description: 'Related epic ID', required: false }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        project: Flags.string({ char: 'P', description: 'Project ID' }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(EpicLinkRelates);
+        // 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 link relates', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const epic = await this.storage.getEpic(args.id);
+        if (!epic)
+            return handleError('EPIC_NOT_FOUND', `Epic not found: ${args.id}`);
+        const projectId = epic.projectId;
+        let targetId = args.target;
+        if (!targetId) {
+            const allEpics = await this.storage.listEpics(projectId);
+            const otherEpics = allEpics.filter(e => e.id !== args.id);
+            if (otherEpics.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_OTHER_EPICS', 'No other epics.', createMetadata('epic link relates', flags));
+                    return;
+                }
+                this.log(styles.muted('\nNo other epics.'));
+                return;
+            }
+            // In JSON mode, output target epic selection prompt
+            if (jsonMode) {
+                const epicChoices = otherEpics.map(e => ({ name: `${e.id} - ${e.title}`, value: e.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'target', `Select epic that ${args.id} relates to:`, epicChoices), createMetadata('epic link relates', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{ type: 'list', name: 'selected', message: `Select epic that ${args.id} relates to:`,
+                    choices: otherEpics.map(e => ({ name: `${e.id} - ${e.title}`, value: e.id })) }]);
+            targetId = selected;
+        }
+        const targetEpic = await this.storage.getEpic(targetId);
+        if (!targetEpic)
+            return handleError('TARGET_EPIC_NOT_FOUND', `Epic not found: ${targetId}`);
+        await this.storage.createEpicDependency(args.id, targetId, 'relates_to');
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\n✅ ${styles.emphasis(args.id)} relates to ${styles.emphasis(targetId)}`));
+    }
+}

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

@@ -0,0 +1,16 @@
+import { PMOCommand } from '../../../lib/pmo/index.js';
+export default class EpicLinkRemove extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        target: 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>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/epic/link/remove.js

@@ -0,0 +1,89 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../../lib/pmo/index.js';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class EpicLinkRemove extends PMOCommand {
+    static description = 'Remove a dependency from an epic';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> EPIC-001 EPIC-002',
+        '<%= config.bin %> <%= command.id %> EPIC-001 --all',
+    ];
+    static args = {
+        id: Args.string({ description: 'Epic ID', required: true }),
+        target: Args.string({ description: 'Target epic ID to unlink', required: false }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        project: Flags.string({ char: 'P', description: 'Project ID' }),
+        type: Flags.string({ char: 't', description: 'Dependency type', options: ['blocks', 'relates_to', 'duplicates'] }),
+        all: Flags.boolean({ char: 'a', description: 'Remove all dependencies', default: false }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(EpicLinkRemove);
+        // 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 link remove', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const epic = await this.storage.getEpic(args.id);
+        if (!epic)
+            return handleError('EPIC_NOT_FOUND', `Epic not found: ${args.id}`);
+        const dependencies = await this.storage.listEpicDependencies(args.id);
+        if (dependencies.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_DEPENDENCIES', `Epic ${args.id} has no dependencies.`, createMetadata('epic link remove', flags));
+                return;
+            }
+            this.log(styles.muted(`\nEpic ${args.id} has no dependencies.`));
+            return;
+        }
+        if (flags.all) {
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                const confirmChoices = [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ];
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', `Remove all ${dependencies.length} dependencies?`, confirmChoices), createMetadata('epic link remove', flags));
+                return;
+            }
+            const { confirmed } = await inquirer.prompt([{ type: 'confirm', name: 'confirmed', message: `Remove all ${dependencies.length} dependencies?`, default: false }]);
+            if (!confirmed) {
+                this.log(styles.muted('\nCancelled.'));
+                return;
+            }
+            for (const dep of dependencies)
+                await this.storage.deleteEpicDependency(args.id, dep.dependsOnEpicId, dep.dependencyType);
+            await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+            this.log(styles.success(`\n✅ Removed ${dependencies.length} dependencies from ${args.id}`));
+            return;
+        }
+        let targetId = args.target;
+        if (!targetId) {
+            const choices = await Promise.all(dependencies.map(async (dep) => {
+                const depEpic = await this.storage.getEpic(dep.dependsOnEpicId);
+                return { name: `${dep.dependsOnEpicId} - ${depEpic?.title || 'Unknown'} (${dep.dependencyType})`, value: dep.dependsOnEpicId };
+            }));
+            // In JSON mode, output dependency selection prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'target', 'Select dependency to remove:', choices), createMetadata('epic link remove', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{ type: 'list', name: 'selected', message: 'Select dependency to remove:', choices }]);
+            targetId = selected;
+        }
+        await this.storage.deleteEpicDependency(args.id, targetId, flags.type);
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\n✅ Removed dependency: ${args.id} → ${targetId}`));
+    }
+}

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

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