@proletariat/cli 0.3.23 → 0.3.25

package/dist/commands/link/create.js

@@ -0,0 +1,141 @@
+import { Args, Flags } from '@oclif/core';
+import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+/**
+ * Infer entity type from ID prefix
+ */
+function inferEntityType(id) {
+    const upper = id.toUpperCase();
+    if (upper.startsWith('TKT-'))
+        return 'ticket';
+    if (upper.startsWith('SPEC-'))
+        return 'spec';
+    if (upper.startsWith('EPIC-'))
+        return 'epic';
+    return null;
+}
+export default class LinkCreate extends PMOCommand {
+    static description = 'Create a link (dependency) between two entities';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 TKT-002 --type blocks    # TKT-001 is blocked by TKT-002',
+        '<%= config.bin %> <%= command.id %> TKT-001 TKT-002 --type relates   # TKT-001 relates to TKT-002',
+        '<%= config.bin %> <%= command.id %> SPEC-001 SPEC-002 --type depends # SPEC-001 depends on SPEC-002',
+        '<%= config.bin %> <%= command.id %> EPIC-001 EPIC-002 --type blocks  # EPIC-001 is blocked by EPIC-002',
+    ];
+    static args = {
+        from: Args.string({
+            description: 'Source entity ID (TKT-xxx, SPEC-xxx, or EPIC-xxx)',
+            required: true,
+        }),
+        to: Args.string({
+            description: 'Target entity ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Link type',
+            options: ['blocks', 'relates', 'duplicates', 'depends'],
+            required: true,
+        }),
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(LinkCreate);
+        const jsonMode = shouldOutputJson(flags);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('link create', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const fromType = inferEntityType(args.from);
+        const toType = inferEntityType(args.to);
+        if (!fromType) {
+            return handleError('INVALID_FROM_ID', `Cannot infer entity type from "${args.from}". Use TKT-, SPEC-, or EPIC- prefix.`);
+        }
+        if (!toType) {
+            return handleError('INVALID_TO_ID', `Cannot infer entity type from "${args.to}". Use TKT-, SPEC-, or EPIC- prefix.`);
+        }
+        if (fromType !== toType) {
+            return handleError('TYPE_MISMATCH', `Cannot link different entity types: ${fromType} and ${toType}`);
+        }
+        const linkType = flags.type;
+        // Validate link type for entity type
+        // Tickets: blocks, relates_to, duplicates
+        // Specs: depends_on, relates_to, duplicates (no blocks)
+        // Epics: blocks, relates_to, duplicates (no depends)
+        if (fromType === 'spec' && linkType === 'blocks') {
+            return handleError('INVALID_LINK_TYPE', 'Specs do not support "blocks" link type. Use "depends" instead.');
+        }
+        if (fromType === 'epic' && linkType === 'depends') {
+            return handleError('INVALID_LINK_TYPE', 'Epics do not support "depends" link type. Use "blocks" instead.');
+        }
+        if (fromType === 'ticket' && linkType === 'depends') {
+            return handleError('INVALID_LINK_TYPE', 'Tickets do not support "depends" link type. Use "blocks" instead.');
+        }
+        // Map the link type to the storage dependency type
+        const dependencyType = linkType === 'relates' ? 'relates_to' :
+            linkType === 'depends' ? 'depends_on' : linkType;
+        try {
+            if (fromType === 'ticket') {
+                const ticket = await this.storage.getTicket(args.from);
+                if (!ticket)
+                    return handleError('FROM_NOT_FOUND', `Ticket not found: ${args.from}`);
+                const targetTicket = await this.storage.getTicket(args.to);
+                if (!targetTicket)
+                    return handleError('TO_NOT_FOUND', `Ticket not found: ${args.to}`);
+                await this.storage.createTicketDependency(args.from, args.to, dependencyType);
+                await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+                this.log(styles.success(`\n✅ Link created: ${styles.emphasis(args.from)} → ${styles.emphasis(args.to)} (${linkType})`));
+                this.log(styles.muted(`   ${ticket.title}`));
+                this.log(styles.muted(`   ${linkType}: ${targetTicket.title}`));
+            }
+            else if (fromType === 'spec') {
+                const spec = await this.storage.getSpec(args.from);
+                if (!spec)
+                    return handleError('FROM_NOT_FOUND', `Spec not found: ${args.from}`);
+                const targetSpec = await this.storage.getSpec(args.to);
+                if (!targetSpec)
+                    return handleError('TO_NOT_FOUND', `Spec not found: ${args.to}`);
+                await this.storage.createSpecDependency(args.from, args.to, dependencyType);
+                this.log(styles.success(`\n✅ Link created: ${styles.emphasis(args.from)} → ${styles.emphasis(args.to)} (${linkType})`));
+                this.log(styles.muted(`   ${spec.title}`));
+                this.log(styles.muted(`   ${linkType}: ${targetSpec.title}`));
+            }
+            else if (fromType === 'epic') {
+                const epic = await this.storage.getEpic(args.from);
+                if (!epic)
+                    return handleError('FROM_NOT_FOUND', `Epic not found: ${args.from}`);
+                const targetEpic = await this.storage.getEpic(args.to);
+                if (!targetEpic)
+                    return handleError('TO_NOT_FOUND', `Epic not found: ${args.to}`);
+                await this.storage.createEpicDependency(args.from, args.to, dependencyType);
+                await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+                this.log(styles.success(`\n✅ Link created: ${styles.emphasis(args.from)} → ${styles.emphasis(args.to)} (${linkType})`));
+                this.log(styles.muted(`   ${epic.title}`));
+                this.log(styles.muted(`   ${linkType}: ${targetEpic.title}`));
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('already exists')) {
+                    return handleError('ALREADY_EXISTS', 'Link already exists');
+                }
+                if (error.message.includes('self-dependency')) {
+                    return handleError('SELF_LINK', 'Cannot create self-link');
+                }
+            }
+            throw error;
+        }
+    }
+}

package/dist/commands/{epic/link/relates.d.ts → link/index.d.ts}

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

package/dist/commands/link/index.js

@@ -0,0 +1,87 @@
+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 { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class Link extends PMOCommand {
+    static description = 'Manage links (dependencies) between entities';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> create TKT-001 TKT-002 --type blocks',
+        '<%= config.bin %> <%= command.id %> list TKT-001',
+        '<%= config.bin %> <%= command.id %> remove TKT-001 TKT-002',
+    ];
+    static args = {
+        action: Args.string({
+            description: 'Action to perform',
+            options: ['create', 'list', 'remove'],
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(Link);
+        const jsonMode = shouldOutputJson(flags);
+        let action = args.action;
+        if (!action) {
+            const menuChoices = [
+                { name: 'Create a new link', value: 'create', command: 'prlt link create --help' },
+                { name: 'List links for an entity', value: 'list', command: 'prlt link list --help' },
+                { name: 'Remove a link', value: 'remove', command: 'prlt link remove --help' },
+                { name: 'Cancel', value: 'cancel', command: '' },
+            ];
+            const message = 'What would you like to do?';
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'action', message, menuChoices), createMetadata('link', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message,
+                    choices: [
+                        ...menuChoices.slice(0, 3).map(c => ({ name: c.name, value: c.value })),
+                        new inquirer.Separator(),
+                        { name: menuChoices[3].name, value: menuChoices[3].value }
+                    ]
+                }]);
+            if (selected === 'cancel') {
+                this.log(styles.muted('\nCancelled.'));
+                return;
+            }
+            action = selected;
+        }
+        // Show help for the selected action
+        this.log(styles.muted(`\nUsage:`));
+        switch (action) {
+            case 'create':
+                this.log('  prlt link create <from> <to> --type <blocks|relates|duplicates|depends>');
+                this.log('');
+                this.log('Examples:');
+                this.log('  prlt link create TKT-001 TKT-002 --type blocks   # TKT-001 is blocked by TKT-002');
+                this.log('  prlt link create SPEC-001 SPEC-002 --type depends # SPEC-001 depends on SPEC-002');
+                break;
+            case 'list':
+                this.log('  prlt link list <entity-id>');
+                this.log('');
+                this.log('Examples:');
+                this.log('  prlt link list TKT-001       # List links for ticket');
+                this.log('  prlt link list SPEC-001 --all # Include reverse links');
+                break;
+            case 'remove':
+                this.log('  prlt link remove <from> <to>');
+                this.log('');
+                this.log('Examples:');
+                this.log('  prlt link remove TKT-001 TKT-002');
+                this.log('  prlt link remove SPEC-001 SPEC-002 --type depends');
+                break;
+        }
+    }
+}

package/dist/commands/{epic/link/duplicates.d.ts → link/list.d.ts}

@@ -1,14 +1,17 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
-export default class EpicLinkDuplicates extends PMOCommand {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class LinkList 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>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     execute(): Promise<void>;
+    private listTicketLinks;
+    private listSpecLinks;
+    private listEpicLinks;
 }

package/dist/commands/link/list.js

@@ -0,0 +1,182 @@
+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';
+/**
+ * Infer entity type from ID prefix
+ */
+function inferEntityType(id) {
+    const upper = id.toUpperCase();
+    if (upper.startsWith('TKT-'))
+        return 'ticket';
+    if (upper.startsWith('SPEC-'))
+        return 'spec';
+    if (upper.startsWith('EPIC-'))
+        return 'epic';
+    return null;
+}
+export default class LinkList extends PMOCommand {
+    static description = 'List all links (dependencies) for an entity';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001       # List ticket links',
+        '<%= config.bin %> <%= command.id %> SPEC-001      # List spec links',
+        '<%= config.bin %> <%= command.id %> EPIC-001      # List epic links',
+        '<%= config.bin %> <%= command.id %> TKT-001 --all # Include reverse links',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Entity ID (TKT-xxx, SPEC-xxx, or EPIC-xxx)',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Show all links including reverse dependencies (what blocks this, what this blocks)',
+            default: false,
+        }),
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output as JSON for AI agents/scripts',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(LinkList);
+        const jsonMode = shouldOutputJson(flags);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('link list', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const entityType = inferEntityType(args.id);
+        if (!entityType) {
+            return handleError('INVALID_ID', `Cannot infer entity type from "${args.id}". Use TKT-, SPEC-, or EPIC- prefix.`);
+        }
+        if (entityType === 'ticket') {
+            await this.listTicketLinks(args.id, flags.all);
+        }
+        else if (entityType === 'spec') {
+            await this.listSpecLinks(args.id, flags.all);
+        }
+        else if (entityType === 'epic') {
+            await this.listEpicLinks(args.id, flags.all);
+        }
+    }
+    async listTicketLinks(ticketId, showAll) {
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            this.error(`Ticket not found: ${ticketId}`);
+        }
+        const dependencies = await this.storage.listTicketDependencies(ticketId);
+        const blockers = await this.storage.getTicketBlockers(ticketId);
+        const isBlocked = await this.storage.isTicketBlocked(ticketId);
+        this.log(`\n${styles.emphasis(ticket.id)}: ${ticket.title}`);
+        if (isBlocked) {
+            this.log(styles.warning('  Status: BLOCKED'));
+        }
+        if (blockers.length > 0) {
+            this.log(styles.muted('\n  Blocked by:'));
+            for (const blocker of blockers) {
+                const status = blocker.status === 'done' ? styles.success('done') : styles.warning(blocker.status);
+                this.log(`    - ${blocker.id}: ${blocker.title} (${status})`);
+            }
+        }
+        const otherDeps = dependencies.filter(d => d.dependencyType !== 'blocks');
+        if (otherDeps.length > 0) {
+            this.log(styles.muted('\n  Related:'));
+            const relatedTickets = await Promise.all(otherDeps.map(async (dep) => ({
+                dep,
+                ticket: await this.storage.getTicket(dep.dependsOnTicketId)
+            })));
+            for (const { dep, ticket: relatedTicket } of relatedTickets) {
+                if (relatedTicket) {
+                    this.log(`    - ${dep.dependencyType}: ${relatedTicket.id} - ${relatedTicket.title}`);
+                }
+            }
+        }
+        if (showAll) {
+            const blockedBy = await this.storage.getTicketsBlockedBy(ticketId);
+            if (blockedBy.length > 0) {
+                this.log(styles.muted('\n  Blocking:'));
+                for (const blocked of blockedBy) {
+                    this.log(`    - ${blocked.id}: ${blocked.title} (${blocked.status})`);
+                }
+            }
+        }
+        if (dependencies.length === 0 && blockers.length === 0) {
+            this.log(styles.muted('\n  No links.'));
+        }
+        this.log('');
+    }
+    async listSpecLinks(specId, showAll) {
+        const spec = await this.storage.getSpec(specId);
+        if (!spec) {
+            this.error(`Spec not found: ${specId}`);
+        }
+        const dependencies = await this.storage.listSpecDependencies(specId);
+        this.log(`\n${styles.emphasis(spec.id)}: ${spec.title}`);
+        if (dependencies.length === 0) {
+            this.log(styles.muted('\n  No links.'));
+            this.log('');
+            return;
+        }
+        // Group by type
+        const byType = {};
+        for (const dep of dependencies) {
+            if (!byType[dep.dependencyType])
+                byType[dep.dependencyType] = [];
+            byType[dep.dependencyType].push(dep);
+        }
+        for (const [depType, deps] of Object.entries(byType)) {
+            this.log(styles.muted(`\n  ${depType}:`));
+            for (const dep of deps) {
+                const targetSpec = await this.storage.getSpec(dep.dependsOnSpecId);
+                if (targetSpec) {
+                    this.log(`    - ${targetSpec.id}: ${targetSpec.title}`);
+                }
+            }
+        }
+        this.log('');
+    }
+    async listEpicLinks(epicId, showAll) {
+        const epic = await this.storage.getEpic(epicId);
+        if (!epic) {
+            this.error(`Epic not found: ${epicId}`);
+        }
+        const dependencies = await this.storage.listEpicDependencies(epicId);
+        this.log(`\n${styles.emphasis(epic.id)}: ${epic.title}`);
+        // Show blocking dependencies
+        const blockingDeps = dependencies.filter(d => d.dependencyType === 'blocks');
+        if (blockingDeps.length > 0) {
+            this.log(styles.muted('\n  Blocked by:'));
+            for (const dep of blockingDeps) {
+                const blocker = await this.storage.getEpic(dep.dependsOnEpicId);
+                if (blocker) {
+                    const status = blocker.status === 'complete' ? styles.success('done') : styles.warning(blocker.status);
+                    this.log(`    - ${blocker.id}: ${blocker.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 targetEpic = await this.storage.getEpic(dep.dependsOnEpicId);
+                if (targetEpic) {
+                    this.log(`    - ${dep.dependencyType}: ${targetEpic.id} - ${targetEpic.title}`);
+                }
+            }
+        }
+        // Note: showAll would show reverse dependencies, but we don't have getEpicsBlockedBy
+        // For now, we just show the epic's own dependencies
+        if (dependencies.length === 0) {
+            this.log(styles.muted('\n  No links.'));
+        }
+        this.log('');
+    }
+}

package/dist/commands/{spec/link → link}/remove.d.ts

@@ -1,14 +1,13 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
-export default class SpecLinkRemove extends PMOCommand {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class LinkRemove 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>>;
+        from: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        to: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
         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>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };

package/dist/commands/link/remove.js

@@ -0,0 +1,120 @@
+import { Args, Flags } from '@oclif/core';
+import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+/**
+ * Infer entity type from ID prefix
+ */
+function inferEntityType(id) {
+    const upper = id.toUpperCase();
+    if (upper.startsWith('TKT-'))
+        return 'ticket';
+    if (upper.startsWith('SPEC-'))
+        return 'spec';
+    if (upper.startsWith('EPIC-'))
+        return 'epic';
+    return null;
+}
+export default class LinkRemove extends PMOCommand {
+    static description = 'Remove a link (dependency) between two entities';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 TKT-002   # Remove link between tickets',
+        '<%= config.bin %> <%= command.id %> SPEC-001 SPEC-002 # Remove link between specs',
+        '<%= config.bin %> <%= command.id %> EPIC-001 EPIC-002 # Remove link between epics',
+    ];
+    static args = {
+        from: Args.string({
+            description: 'Source entity ID (TKT-xxx, SPEC-xxx, or EPIC-xxx)',
+            required: true,
+        }),
+        to: Args.string({
+            description: 'Target entity ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Link type to remove (if not specified, removes any link)',
+            options: ['blocks', 'relates', 'duplicates', 'depends'],
+        }),
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(LinkRemove);
+        const jsonMode = shouldOutputJson(flags);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('link remove', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const fromType = inferEntityType(args.from);
+        const toType = inferEntityType(args.to);
+        if (!fromType) {
+            return handleError('INVALID_FROM_ID', `Cannot infer entity type from "${args.from}". Use TKT-, SPEC-, or EPIC- prefix.`);
+        }
+        if (!toType) {
+            return handleError('INVALID_TO_ID', `Cannot infer entity type from "${args.to}". Use TKT-, SPEC-, or EPIC- prefix.`);
+        }
+        if (fromType !== toType) {
+            return handleError('TYPE_MISMATCH', `Cannot link different entity types: ${fromType} and ${toType}`);
+        }
+        // Map the link type to the storage dependency type
+        const linkType = flags.type;
+        const dependencyType = linkType === 'relates' ? 'relates_to' :
+            linkType === 'depends' ? 'depends_on' : linkType;
+        try {
+            if (fromType === 'ticket') {
+                const ticket = await this.storage.getTicket(args.from);
+                if (!ticket)
+                    return handleError('FROM_NOT_FOUND', `Ticket not found: ${args.from}`);
+                const targetTicket = await this.storage.getTicket(args.to);
+                if (!targetTicket)
+                    return handleError('TO_NOT_FOUND', `Ticket not found: ${args.to}`);
+                await this.storage.deleteTicketDependency(args.from, args.to, dependencyType);
+                await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+                this.log(styles.success(`\n✅ Link removed: ${styles.emphasis(args.from)} → ${styles.emphasis(args.to)}`));
+                this.log(styles.muted(`   ${ticket.title} no longer linked to ${targetTicket.title}`));
+            }
+            else if (fromType === 'spec') {
+                const spec = await this.storage.getSpec(args.from);
+                if (!spec)
+                    return handleError('FROM_NOT_FOUND', `Spec not found: ${args.from}`);
+                const targetSpec = await this.storage.getSpec(args.to);
+                if (!targetSpec)
+                    return handleError('TO_NOT_FOUND', `Spec not found: ${args.to}`);
+                await this.storage.deleteSpecDependency(args.from, args.to, dependencyType);
+                this.log(styles.success(`\n✅ Link removed: ${styles.emphasis(args.from)} → ${styles.emphasis(args.to)}`));
+                this.log(styles.muted(`   ${spec.title} no longer linked to ${targetSpec.title}`));
+            }
+            else if (fromType === 'epic') {
+                const epic = await this.storage.getEpic(args.from);
+                if (!epic)
+                    return handleError('FROM_NOT_FOUND', `Epic not found: ${args.from}`);
+                const targetEpic = await this.storage.getEpic(args.to);
+                if (!targetEpic)
+                    return handleError('TO_NOT_FOUND', `Epic not found: ${args.to}`);
+                await this.storage.deleteEpicDependency(args.from, args.to, dependencyType);
+                await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+                this.log(styles.success(`\n✅ Link removed: ${styles.emphasis(args.from)} → ${styles.emphasis(args.to)}`));
+                this.log(styles.muted(`   ${epic.title} no longer linked to ${targetEpic.title}`));
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('not found')) {
+                    return handleError('LINK_NOT_FOUND', 'Link not found');
+                }
+            }
+            throw error;
+        }
+    }
+}

package/dist/commands/mcp-server.d.ts

@@ -0,0 +1,22 @@
+/**
+ * MCP Server Command
+ *
+ * Comprehensive MCP (Model Context Protocol) server exposing ALL prlt commands
+ * as tools for AI agent integration.
+ *
+ * Usage in Claude Code config:
+ * ```json
+ * {
+ *   "mcpServers": {
+ *     "prlt": { "command": "prlt", "args": ["mcp-server"] }
+ *   }
+ * }
+ * ```
+ */
+import { Command } from '@oclif/core';
+export default class McpServerCommand extends Command {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    run(): Promise<void>;
+}