@proletariat/cli 0.3.23 → 0.3.24

package/dist/commands/action/create.js

@@ -21,7 +21,7 @@ export default class ActionCreate extends PMOCommand {
         ...pmoBaseFlags,
         prompt: Flags.string({
             char: 'p',
-            description: 'The prompt to send to the agent',
+            description: 'The prompt to send to the agent [required for non-interactive]',
         }),
         description: Flags.string({
             char: 'd',

package/dist/commands/agent/{temp/cleanup.d.ts → cleanup.d.ts}

@@ -1,4 +1,4 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
+import { PMOCommand } from '../../lib/pmo/index.js';
 export default class Cleanup extends PMOCommand {
     static description: string;
     static examples: string[];

package/dist/commands/agent/{temp/cleanup.js → cleanup.js}

@@ -1,9 +1,9 @@
 import { Args, Flags } from '@oclif/core';
 import inquirer from 'inquirer';
-import { colors, format } from '../../../lib/colors.js';
-import { getWorkspaceInfo, cleanupAgent, getCleanableAgents, getAgentTmuxSessions } from '../../../lib/agents/commands.js';
-import { PMOCommand, pmoBaseFlags } from '../../../lib/pmo/index.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, outputSuccessAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+import { colors, format } from '../../lib/colors.js';
+import { getWorkspaceInfo, cleanupAgent, getCleanableAgents, getAgentTmuxSessions } from '../../lib/agents/commands.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, outputSuccessAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
 export default class Cleanup extends PMOCommand {
     static description = 'Clean up agent resources (containers, directories, tmux sessions)';
     static examples = [

package/dist/commands/agent/index.js

@@ -10,7 +10,7 @@ export default class Agent extends PMOCommand {
         '<%= config.bin %> <%= command.id %> visit tacoma',
         '<%= config.bin %> <%= command.id %> staff add',
         '<%= config.bin %> <%= command.id %> staff remove camry',
-        '<%= config.bin %> <%= command.id %> temp cleanup --temp',
+        '<%= config.bin %> <%= command.id %> cleanup --temp',
         '<%= config.bin %> <%= command.id %> restart altman',
         '<%= config.bin %> <%= command.id %> rebuild altman',
         '<%= config.bin %> <%= command.id %> shell altman',
@@ -52,7 +52,7 @@ export default class Agent extends PMOCommand {
                     { name: '🗑️  Remove agent', value: 'remove', command: 'prlt agent remove --machine' },
                     // Management group
                     { name: '👔 Manage staff agents', value: 'staff', command: 'prlt agent staff --machine' },
-                    { name: '⏱️  Manage temp agents', value: 'temp', command: 'prlt agent temp --machine' },
+                    { name: '🧹 Cleanup agents', value: 'cleanup', command: 'prlt agent cleanup --machine' },
                     { name: '🎨 Manage themes', value: 'themes', command: 'prlt agent themes --machine' },
                     // Operations group
                     { name: '🐚 Open shell', value: 'shell', command: 'prlt agent shell --machine' },
@@ -96,20 +96,20 @@ export default class Agent extends PMOCommand {
                     break;
                 }
                 case 'staff': {
-                    const { default: StaffCommand } = await import('./staff/index.js');
+                    const { default: StaffCommand } = await import('../staff/index.js');
                     const cmd = new StaffCommand([], this.config);
                     await cmd.run();
                     break;
                 }
-                case 'temp': {
-                    const { default: TempCommand } = await import('./temp/index.js');
-                    const cmd = new TempCommand([], this.config);
+                case 'cleanup': {
+                    const { default: CleanupCommand } = await import('./cleanup.js');
+                    const cmd = new CleanupCommand([], this.config);
                     await cmd.run();
                     break;
                 }
                 case 'themes': {
-                    const { default: ThemesCommand } = await import('./themes/index.js');
-                    const cmd = new ThemesCommand([], this.config);
+                    const { default: ThemeCommand } = await import('../theme/index.js');
+                    const cmd = new ThemeCommand([], this.config);
                     await cmd.run();
                     break;
                 }

package/dist/commands/branch/create.js

@@ -38,7 +38,7 @@ export default class BranchCreate extends PMOCommand {
         }),
         type: Flags.string({
             char: 't',
-            description: 'Branch type',
+            description: 'Branch type [required for non-interactive with -d]',
             options: Object.keys(BRANCH_TYPES),
         }),
         owner: Flags.string({
@@ -47,7 +47,7 @@ export default class BranchCreate extends PMOCommand {
         }),
         description: Flags.string({
             char: 'd',
-            description: 'Branch description (kebab-case)',
+            description: 'Branch description (kebab-case) [required for non-interactive with -t]',
         }),
         'empty-commit': Flags.boolean({
             char: 'e',

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

@@ -8,6 +8,7 @@ export default class EpicCreate extends PMOCommand {
         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>;
+        'dry-run': 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/create.js

@@ -3,7 +3,7 @@ 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';
+import { shouldOutputJson, outputPromptAsJson, outputDryRunSuccessAsJson, outputDryRunErrorsAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
 export default class EpicCreate extends PMOCommand {
     static description = 'Create a new epic';
     static examples = [
@@ -11,12 +11,13 @@ export default class EpicCreate extends PMOCommand {
         '<%= 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',
+        '<%= config.bin %> <%= command.id %> --title "Test" -P PROJ-001 --dry-run --json  # Validate without creating',
     ];
     static flags = {
         ...pmoBaseFlags,
         title: Flags.string({
             char: 't',
-            description: 'Epic title',
+            description: 'Epic title [required for non-interactive]',
         }),
         status: Flags.string({
             char: 's',
@@ -37,6 +38,10 @@ export default class EpicCreate extends PMOCommand {
             description: 'Output prompt configuration as JSON (for AI agents/scripts)',
             default: false,
         }),
+        'dry-run': Flags.boolean({
+            description: 'Validate inputs without creating epic (use with --json for structured output)',
+            default: false,
+        }),
     };
     async execute() {
         const { flags } = await this.parse(EpicCreate);
@@ -90,9 +95,41 @@ export default class EpicCreate extends PMOCommand {
         if (epicData.specId) {
             const spec = await this.storage.getSpec(epicData.specId);
             if (!spec) {
+                if (flags['dry-run']) {
+                    if (jsonMode) {
+                        outputDryRunErrorsAsJson([{ field: 'spec', error: `Spec not found: ${epicData.specId}` }], createMetadata('epic create', flags));
+                    }
+                }
                 this.error(`Spec not found: ${epicData.specId}`);
             }
         }
+        // Handle dry-run: show what would be created without actually creating
+        if (flags['dry-run']) {
+            const projectName = await this.getProjectName(projectId);
+            const wouldCreate = {
+                title: epicData.title,
+                project: projectId,
+                status: epicData.status,
+                ...(epicData.description && { description: epicData.description }),
+                ...(epicData.specId && { spec: epicData.specId }),
+            };
+            if (jsonMode) {
+                outputDryRunSuccessAsJson('epic', wouldCreate, createMetadata('epic create', flags));
+            }
+            // Human-readable dry-run output
+            this.log(styles.warning('\n[DRY RUN] Would create epic:'));
+            this.log(styles.muted(`   Title: ${epicData.title}`));
+            this.log(styles.muted(`   Project: ${projectName}`));
+            this.log(styles.muted(`   Status: ${epicData.status}`));
+            if (epicData.description) {
+                this.log(styles.muted(`   Description: ${epicData.description}`));
+            }
+            if (epicData.specId) {
+                this.log(styles.muted(`   Spec: ${epicData.specId}`));
+            }
+            this.log(styles.muted('\n(No epic was created)'));
+            return;
+        }
         const epic = await this.storage.createEpic(projectId, {
             title: epicData.title,
             status: epicData.status,

package/dist/commands/epic/index.js

@@ -31,7 +31,7 @@ export default class Epic extends PMOCommand {
             { 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: 'link', name: 'Manage dependencies', command: 'prlt link list --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' },
@@ -72,7 +72,7 @@ export default class Epic extends PMOCommand {
                 await this.config.runCommand('epic:spec', []);
                 break;
             case 'link':
-                await this.config.runCommand('epic:link', []);
+                await this.config.runCommand('link', []);
                 break;
             case 'archive':
                 await this.config.runCommand('epic:archive', []);

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

@@ -1,16 +1,15 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
-export default class EpicLinkRemove extends PMOCommand {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class LinkCreate 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: {
-        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>;
+        type: import("@oclif/core/interfaces").OptionFlag<string, 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/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;
 }