@proletariat/cli 0.3.22 → 0.3.24

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

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