@proletariat/cli 0.3.23 → 0.3.24

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>;
+}

package/dist/commands/mcp-server.js

@@ -0,0 +1,98 @@
+/**
+ * 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';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { execSync } from 'node:child_process';
+import * as path from 'node:path';
+import { getPMOContext } from '../lib/pmo/pmo-context.js';
+import { registerTicketTools, registerProjectTools, registerBoardTools, registerSpecTools, registerEpicTools, registerWorkTools, registerWorkflowTools, registerStatusTools, registerPhaseTools, registerActionTools, registerRoadmapTools, registerCategoryTools, registerTemplateTools, registerViewTools, registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from '../lib/mcp/index.js';
+export default class McpServerCommand extends Command {
+    static description = 'Start MCP server for AI agent integration (exposes all prlt commands as tools)';
+    static hidden = true;
+    static examples = ['<%= config.bin %> mcp-server'];
+    async run() {
+        // Initialize PMO context (may be null if not in a workspace)
+        let pmoContext = null;
+        try {
+            pmoContext = await getPMOContext({ logger: () => { } });
+        }
+        catch {
+            pmoContext = null;
+        }
+        // Create MCP server
+        const server = new McpServer({
+            name: 'prlt',
+            version: this.config.version,
+        });
+        // Create tool context
+        const ctx = {
+            get storage() {
+                if (!pmoContext) {
+                    throw new Error('PMO not initialized. Run "prlt init" first.');
+                }
+                return pmoContext.storage;
+            },
+            runCommand: (cmd) => {
+                try {
+                    const result = execSync(cmd, {
+                        encoding: 'utf-8',
+                        cwd: process.cwd(),
+                        env: {
+                            ...process.env,
+                            PATH: `${path.dirname(process.execPath)}:${process.env.PATH}`,
+                        },
+                        maxBuffer: 10 * 1024 * 1024,
+                    });
+                    return result.trim();
+                }
+                catch (error) {
+                    const execError = error;
+                    if (execError.stderr)
+                        return execError.stderr.trim();
+                    if (execError.stdout)
+                        return execError.stdout.trim();
+                    throw error;
+                }
+            },
+        };
+        // Register all tool categories
+        registerTicketTools(server, ctx);
+        registerProjectTools(server, ctx);
+        registerBoardTools(server, ctx);
+        registerSpecTools(server, ctx);
+        registerEpicTools(server, ctx);
+        registerWorkTools(server, ctx);
+        registerWorkflowTools(server, ctx);
+        registerStatusTools(server, ctx);
+        registerPhaseTools(server, ctx);
+        registerActionTools(server, ctx);
+        registerRoadmapTools(server, ctx);
+        registerCategoryTools(server, ctx);
+        registerTemplateTools(server, ctx);
+        registerViewTools(server, ctx);
+        registerAgentTools(server, ctx);
+        registerDockerTools(server, ctx);
+        registerRepoTools(server, ctx);
+        registerBranchTools(server, ctx);
+        registerGitHubTools(server, ctx);
+        registerInitTools(server, ctx);
+        registerUtilityTools(server, ctx);
+        // Connect via stdio transport
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+    }
+}

package/dist/commands/phase/create.js

@@ -21,7 +21,7 @@ export default class PhaseCreate extends PMOCommand {
         ...pmoBaseFlags,
         category: Flags.string({
             char: 'c',
-            description: 'State category',
+            description: 'State category [required for non-interactive]',
             options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
         }),
         color: Flags.string({

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

@@ -11,6 +11,7 @@ export default class ProjectCreate extends PMOCommand {
         description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         template: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': 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/project/create.js

@@ -5,7 +5,7 @@ import inquirer from 'inquirer';
 import { createBoardContent, createSpecFolders, PMOCommand, pmoBaseFlags, BUILTIN_TEMPLATES } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { slugify } from '../../lib/pmo/utils.js';
-import { shouldOutputJson, outputPromptAsJson, outputSuccessAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputPromptAsJson, outputSuccessAsJson, outputDryRunSuccessAsJson, outputDryRunErrorsAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
 // Build template options dynamically from shared definitions
 const TEMPLATE_IDS = BUILTIN_TEMPLATES.map(t => t.id);
 export default class ProjectCreate extends PMOCommand {
@@ -14,6 +14,7 @@ export default class ProjectCreate extends PMOCommand {
         '<%= config.bin %> <%= command.id %> "My New Project"',
         '<%= config.bin %> <%= command.id %> --name "Mobile App" --description "iOS and Android app"',
         '<%= config.bin %> <%= command.id %> -i  # Interactive mode',
+        '<%= config.bin %> <%= command.id %> --name "Test" --dry-run --json  # Validate without creating',
     ];
     static args = {
         name: Args.string({
@@ -25,7 +26,7 @@ export default class ProjectCreate extends PMOCommand {
         ...pmoBaseFlags,
         name: Flags.string({
             char: 'n',
-            description: 'Project name',
+            description: 'Project name [required for non-interactive]',
         }),
         id: Flags.string({
             description: 'Custom project ID (auto-generated from name if not provided)',
@@ -45,6 +46,10 @@ export default class ProjectCreate extends PMOCommand {
             description: 'Interactive mode',
             default: false,
         }),
+        'dry-run': Flags.boolean({
+            description: 'Validate inputs without creating project (use with --json for structured output)',
+            default: false,
+        }),
     };
     getPMOOptions() {
         return { promptIfMultiple: false };
@@ -86,8 +91,39 @@ export default class ProjectCreate extends PMOCommand {
         // Check if project already exists
         const existing = await this.storage.getProject(projectId);
         if (existing) {
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputDryRunErrorsAsJson([{ field: 'id', error: `Project "${projectId}" already exists` }], createMetadata('project create', flags));
+                }
+            }
             this.error(`Project "${projectId}" already exists.`);
         }
+        // Get the statuses from the workflow (for dry-run preview)
+        const statuses = await this.storage.listStatuses(projectData.template);
+        // Handle dry-run: show what would be created without actually creating
+        if (flags['dry-run']) {
+            const wouldCreate = {
+                id: projectId,
+                name: projectData.name,
+                template: projectData.template,
+                statuses: statuses.map(s => s.name),
+                ...(projectData.description && { description: projectData.description }),
+            };
+            if (jsonMode) {
+                outputDryRunSuccessAsJson('project', wouldCreate, createMetadata('project create', flags));
+            }
+            // Human-readable dry-run output
+            this.log(styles.warning('\n[DRY RUN] Would create project:'));
+            this.log(styles.muted(`   ID: ${projectId}`));
+            this.log(styles.muted(`   Name: ${projectData.name}`));
+            this.log(styles.muted(`   Template: ${projectData.template}`));
+            this.log(styles.muted(`   Statuses: ${statuses.map(s => s.name).join(' → ')}`));
+            if (projectData.description) {
+                this.log(styles.muted(`   Description: ${projectData.description}`));
+            }
+            this.log(styles.muted('\n(No project was created)'));
+            return;
+        }
         // Create project in database
         const project = await this.storage.createProject({
             id: projectId,
@@ -104,8 +140,6 @@ export default class ProjectCreate extends PMOCommand {
         fs.writeFileSync(boardPath, boardContent);
         // Create spec folders in project directory
         const specsPath = createSpecFolders(this.pmoPath, projectId);
-        // Get the statuses from the workflow (template name = workflow ID for built-in templates)
-        const statuses = await this.storage.listStatuses(projectData.template);
         // In JSON mode, output success with project details
         if (jsonMode) {
             outputSuccessAsJson({

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

@@ -11,6 +11,7 @@ export default class SpecCreate extends PMOCommand {
         type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         problem: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': 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/spec/create.js

@@ -2,7 +2,7 @@ import { Flags, Args } from '@oclif/core';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { slugify } from '../../lib/pmo/utils.js';
-import { shouldOutputJson } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputDryRunSuccessAsJson, outputDryRunErrorsAsJson, createMetadata, } from '../../lib/prompt-json.js';
 import { FlagResolver } from '../../lib/flags/index.js';
 export default class SpecCreate extends PMOCommand {
     static description = 'Create a new spec';
@@ -10,6 +10,7 @@ export default class SpecCreate extends PMOCommand {
         '<%= config.bin %> <%= command.id %> "User Authentication"',
         '<%= config.bin %> <%= command.id %> --title "API Design" --type product',
         '<%= config.bin %> <%= command.id %> -i  # Interactive mode',
+        '<%= config.bin %> <%= command.id %> --title "Test" --dry-run --json  # Validate without creating',
     ];
     static args = {
         title: Args.string({
@@ -21,7 +22,7 @@ export default class SpecCreate extends PMOCommand {
         ...pmoBaseFlags,
         title: Flags.string({
             char: 't',
-            description: 'Spec title',
+            description: 'Spec title [required for non-interactive]',
         }),
         status: Flags.string({
             char: 's',
@@ -41,6 +42,10 @@ export default class SpecCreate extends PMOCommand {
             description: 'Interactive mode',
             default: false,
         }),
+        'dry-run': Flags.boolean({
+            description: 'Validate inputs without creating spec (use with --json for structured output)',
+            default: false,
+        }),
     };
     async execute() {
         const { args, flags } = await this.parse(SpecCreate);
@@ -108,6 +113,42 @@ export default class SpecCreate extends PMOCommand {
         const specType = resolved.type === '' ? undefined : resolved.type;
         // Generate ID from title
         const specId = slugify(resolved.title);
+        // Check if spec already exists
+        const existing = await this.storage.getSpec(specId);
+        if (existing) {
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputDryRunErrorsAsJson([{ field: 'id', error: `Spec "${specId}" already exists` }], createMetadata('spec create', flags));
+                }
+            }
+            this.error(`Spec "${specId}" already exists.`);
+        }
+        // Handle dry-run: show what would be created without actually creating
+        if (flags['dry-run']) {
+            const wouldCreate = {
+                id: specId,
+                title: resolved.title,
+                status: resolved.status || 'draft',
+                ...(specType && { type: specType }),
+                ...(resolved.problem && { problem: resolved.problem }),
+            };
+            if (jsonMode) {
+                outputDryRunSuccessAsJson('spec', wouldCreate, createMetadata('spec create', flags));
+            }
+            // Human-readable dry-run output
+            this.log(styles.warning('\n[DRY RUN] Would create spec:'));
+            this.log(styles.muted(`   ID: ${specId}`));
+            this.log(styles.muted(`   Title: ${resolved.title}`));
+            this.log(styles.muted(`   Status: ${resolved.status || 'draft'}`));
+            if (specType) {
+                this.log(styles.muted(`   Type: ${specType}`));
+            }
+            if (resolved.problem) {
+                this.log(styles.muted(`   Problem: ${resolved.problem}`));
+            }
+            this.log(styles.muted('\n(No spec was created)'));
+            return;
+        }
         // Create spec in database
         const spec = await this.storage.createSpec({
             id: specId,

package/dist/commands/spec/index.js

@@ -48,7 +48,7 @@ export default class Spec extends PMOCommand {
                     delete: 'prlt spec delete --json',
                     generate: 'prlt spec plan --json',
                     ticket: 'prlt spec ticket --json',
-                    link: 'prlt spec link --json',
+                    link: 'prlt link list --json',
                     cancel: '',
                 };
                 return commands[value] || '';
@@ -80,7 +80,7 @@ export default class Spec extends PMOCommand {
                 await this.config.runCommand('spec:ticket', []);
                 break;
             case 'link':
-                await this.config.runCommand('spec:link', []);
+                await this.config.runCommand('link', []);
                 break;
         }
     }