@proletariat/cli 0.1.4 → 0.3.0

package/dist/commands/pr/link.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class PRLink extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        pr: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/pr/link.js

@@ -0,0 +1,212 @@
+import { Command, Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import inquirer from 'inquirer';
+import { getPMOContext } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { isGHInstalled, isGHAuthenticated, getPRByNumber, listOpenPRs, } from '../../lib/pr/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class PRLink extends Command {
+    static description = 'Link an existing GitHub pull request to a ticket';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> TKT-001',
+        '<%= config.bin %> <%= command.id %> TKT-001 --pr 123',
+        '<%= config.bin %> <%= command.id %> TKT-001 --url https://github.com/owner/repo/pull/123',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID to link PR to',
+            required: false,
+        }),
+    };
+    static flags = {
+        pr: Flags.integer({
+            char: 'p',
+            description: 'PR number to link',
+        }),
+        url: Flags.string({
+            char: 'u',
+            description: 'PR URL to link',
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PRLink);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('pr link', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Check gh CLI
+        if (!isGHInstalled()) {
+            return handleError('GH_NOT_INSTALLED', 'GitHub CLI (gh) is not installed. Install it from https://cli.github.com/');
+        }
+        if (!isGHAuthenticated()) {
+            return handleError('GH_NOT_AUTHENTICATED', 'GitHub CLI is not authenticated. Run "gh auth login" first.');
+        }
+        // Get workspace and PMO context
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            return handleError('NOT_IN_WORKSPACE', 'Not in a workspace. Run "prlt init" first.');
+        }
+        const { storage } = await getPMOContext({
+            logger: (msg) => this.log(styles.muted(msg)),
+        });
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        const db = new Database(dbPath);
+        try {
+            // Get ticket ID
+            let ticketId = args.ticketId;
+            if (!ticketId) {
+                const projectId = flags.project;
+                const allTickets = await storage.listTickets(projectId);
+                const activeTickets = allTickets.filter(t => t.statusName && !t.statusName.toLowerCase().includes('done') && !t.statusName.toLowerCase().includes('archive'));
+                if (activeTickets.length === 0) {
+                    await storage.close();
+                    db.close();
+                    if (jsonMode) {
+                        outputErrorAsJson('NO_ACTIVE_TICKETS', 'No active tickets found.', createMetadata('pr link', flags));
+                        this.exit(1);
+                    }
+                    this.log(styles.info('No active tickets found.'));
+                    return;
+                }
+                // Build choices once, use for both JSON and interactive modes
+                const ticketChoices = activeTickets.map(t => ({
+                    name: `${t.id} - ${t.title} (${t.statusName})`,
+                    value: t.id,
+                }));
+                const ticketMessage = 'Select ticket to link PR to:';
+                // In JSON mode, output ticket selection prompt and exit
+                if (jsonMode) {
+                    outputPromptAsJson(buildPromptConfig('list', 'ticketId', ticketMessage, ticketChoices), createMetadata('pr link', flags));
+                }
+                const { selectedTicketId } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selectedTicketId',
+                        message: ticketMessage,
+                        choices: ticketChoices,
+                    }]);
+                ticketId = selectedTicketId;
+            }
+            // Get ticket
+            const ticket = await storage.getTicket(ticketId);
+            if (!ticket) {
+                await storage.close();
+                db.close();
+                this.error(`Ticket "${ticketId}" not found.`);
+            }
+            // Check if ticket already has a PR linked
+            if (ticket.metadata?.pr_url) {
+                // Build choices once, use for both JSON and interactive modes
+                const confirmChoices = [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ];
+                const confirmMessage = `Ticket ${ticketId} already has a linked PR (${ticket.metadata.pr_url}). Replace with a different PR?`;
+                // In JSON mode, output overwrite confirmation prompt and exit
+                if (jsonMode) {
+                    outputPromptAsJson(buildPromptConfig('list', 'overwrite', confirmMessage, confirmChoices), createMetadata('pr link', flags));
+                }
+                this.log(styles.info(`Ticket ${ticketId} already has a linked PR:`));
+                this.log(styles.muted(`   URL: ${ticket.metadata.pr_url}`));
+                const { overwrite } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'overwrite',
+                        message: 'Replace with a different PR?',
+                        choices: confirmChoices.map(c => ({ name: c.name, value: c.value === 'true' })),
+                        default: false,
+                    }]);
+                if (!overwrite) {
+                    await storage.close();
+                    db.close();
+                    return;
+                }
+            }
+            // Get PR number
+            let prNumber = flags.pr;
+            const prUrl = flags.url;
+            if (prUrl) {
+                // Extract PR number from URL
+                const urlMatch = prUrl.match(/\/pull\/(\d+)/);
+                if (urlMatch) {
+                    prNumber = parseInt(urlMatch[1], 10);
+                }
+                else {
+                    this.error('Invalid PR URL format. Expected: https://github.com/owner/repo/pull/123');
+                }
+            }
+            if (!prNumber) {
+                // List open PRs for selection
+                const openPRs = listOpenPRs();
+                if (openPRs.length === 0) {
+                    await storage.close();
+                    db.close();
+                    if (jsonMode) {
+                        outputErrorAsJson('NO_OPEN_PRS', 'No open PRs found. Create one first with "prlt pr create".', createMetadata('pr link', flags));
+                        this.exit(1);
+                    }
+                    this.error('No open PRs found. Create one first with "prlt pr create".');
+                }
+                // Build choices once, use for both JSON and interactive modes
+                const prChoices = openPRs.map(pr => ({
+                    name: `#${pr.number} - ${pr.title} (${pr.headBranch})`,
+                    value: String(pr.number),
+                }));
+                const prMessage = 'Select PR to link:';
+                // In JSON mode, output PR selection prompt and exit
+                if (jsonMode) {
+                    outputPromptAsJson(buildPromptConfig('list', 'prNumber', prMessage, prChoices), createMetadata('pr link', flags));
+                }
+                const { selectedPR } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selectedPR',
+                        message: prMessage,
+                        choices: prChoices.map(c => ({ name: c.name, value: parseInt(c.value, 10) })),
+                    }]);
+                prNumber = selectedPR;
+            }
+            // Get PR info
+            const prInfo = getPRByNumber(prNumber);
+            if (!prInfo) {
+                await storage.close();
+                db.close();
+                this.error(`PR #${prNumber} not found.`);
+            }
+            // Link PR to ticket
+            await storage.updateTicket(ticketId, {
+                metadata: {
+                    ...ticket.metadata,
+                    pr_url: prInfo.url,
+                    pr_number: String(prInfo.number),
+                    pr_branch: prInfo.headBranch,
+                },
+            });
+            await storage.close();
+            db.close();
+            this.log('');
+            this.log(styles.success(`PR linked to ticket!`));
+            this.log(styles.muted(`   Ticket: ${ticketId}`));
+            this.log(styles.muted(`   PR: #${prInfo.number} - ${prInfo.title}`));
+            this.log(styles.muted(`   URL: ${prInfo.url}`));
+        }
+        catch (error) {
+            await storage.close();
+            db.close();
+            throw error;
+        }
+    }
+}

package/dist/commands/pr/status.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class PRStatus extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        ticketId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/pr/status.js

@@ -0,0 +1,161 @@
+import { Command, Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import inquirer from 'inquirer';
+import { getPMOContext } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { isGHInstalled, isGHAuthenticated, getPRByNumber, } from '../../lib/pr/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class PRStatus extends Command {
+    static description = 'View PR status for a ticket';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> TKT-001',
+    ];
+    static args = {
+        ticketId: Args.string({
+            description: 'Ticket ID to check PR status for',
+            required: false,
+        }),
+    };
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PRStatus);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('pr status', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get workspace and PMO context
+        let workspaceInfo;
+        try {
+            workspaceInfo = getWorkspaceInfo();
+        }
+        catch {
+            return handleError('NOT_IN_WORKSPACE', 'Not in a workspace. Run "prlt init" first.');
+        }
+        const { storage } = await getPMOContext({
+            logger: (msg) => this.log(styles.muted(msg)),
+        });
+        const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+        const db = new Database(dbPath);
+        try {
+            // Get ticket ID
+            let ticketId = args.ticketId;
+            if (!ticketId) {
+                const projectId = flags.project;
+                const allTickets = await storage.listTickets(projectId);
+                // Filter to tickets that have a PR linked
+                const ticketsWithPR = allTickets.filter(t => t.metadata?.pr_url);
+                const ticketsWithoutPR = allTickets.filter(t => !t.metadata?.pr_url && t.statusName && !t.statusName.toLowerCase().includes('done'));
+                if (ticketsWithPR.length === 0 && ticketsWithoutPR.length === 0) {
+                    await storage.close();
+                    db.close();
+                    this.log(styles.info('No tickets found.'));
+                    return;
+                }
+                // Build choices once, use for both JSON and interactive modes
+                const ticketsWithPRChoices = ticketsWithPR.map(t => ({
+                    name: `${t.id} - ${t.title} [PR linked]`,
+                    value: t.id,
+                }));
+                const ticketsWithoutPRChoices = ticketsWithoutPR.slice(0, 10).map(t => ({
+                    name: `${t.id} - ${t.title} (${t.statusName})`,
+                    value: t.id,
+                }));
+                const ticketChoices = [...ticketsWithPRChoices, ...ticketsWithoutPRChoices];
+                const message = 'Select ticket to check PR status:';
+                // In JSON mode, output ticket selection prompt and exit
+                if (jsonMode) {
+                    outputPromptAsJson(buildPromptConfig('list', 'ticketId', message, ticketChoices), createMetadata('pr status', flags));
+                }
+                // Build interactive choices with separator
+                const interactiveChoices = [...ticketsWithPRChoices];
+                if (ticketsWithoutPRChoices.length > 0) {
+                    interactiveChoices.push(new inquirer.Separator('── No PR Linked ──'));
+                    interactiveChoices.push(...ticketsWithoutPRChoices);
+                }
+                const { selectedTicketId } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selectedTicketId',
+                        message,
+                        choices: interactiveChoices,
+                    }]);
+                ticketId = selectedTicketId;
+            }
+            // Get ticket
+            const ticket = await storage.getTicket(ticketId);
+            if (!ticket) {
+                await storage.close();
+                db.close();
+                this.error(`Ticket "${ticketId}" not found.`);
+            }
+            this.log('');
+            this.log(styles.header(`PR Status: ${ticket.id}`));
+            this.log(styles.muted(`   Title: ${ticket.title}`));
+            this.log(styles.muted(`   Status: ${ticket.statusName}`));
+            this.log('');
+            if (!ticket.metadata?.pr_url) {
+                this.log(styles.info('No PR linked to this ticket.'));
+                this.log(styles.muted('   Use "prlt pr create" or "prlt pr link" to link a PR.'));
+                await storage.close();
+                db.close();
+                return;
+            }
+            // Check gh CLI for live status
+            if (!isGHInstalled() || !isGHAuthenticated()) {
+                this.log(styles.muted('   PR URL:'), ticket.metadata.pr_url);
+                this.log(styles.muted('   (Install and authenticate `gh` CLI for live status)'));
+                await storage.close();
+                db.close();
+                return;
+            }
+            const prNumber = parseInt(ticket.metadata.pr_number || '0', 10);
+            if (!prNumber) {
+                this.log(styles.muted('   PR URL:'), ticket.metadata.pr_url);
+                await storage.close();
+                db.close();
+                return;
+            }
+            const prInfo = getPRByNumber(prNumber);
+            if (!prInfo) {
+                this.log(styles.warning('Unable to fetch PR status (PR may have been deleted).'));
+                this.log(styles.muted('   Stored URL:'), ticket.metadata.pr_url);
+                await storage.close();
+                db.close();
+                return;
+            }
+            // Display PR status
+            const stateEmoji = {
+                OPEN: '🟢',
+                CLOSED: '🔴',
+                MERGED: '🟣',
+            };
+            this.log(styles.success(`${stateEmoji[prInfo.state]} PR #${prInfo.number}: ${prInfo.title}`));
+            this.log('');
+            this.log(styles.muted(`   State: ${prInfo.state}${prInfo.isDraft ? ' (Draft)' : ''}`));
+            this.log(styles.muted(`   Branch: ${prInfo.headBranch} → ${prInfo.baseBranch}`));
+            this.log(styles.muted(`   URL: ${prInfo.url}`));
+            this.log(styles.muted(`   Created: ${new Date(prInfo.createdAt).toLocaleDateString()}`));
+            this.log(styles.muted(`   Updated: ${new Date(prInfo.updatedAt).toLocaleDateString()}`));
+            await storage.close();
+            db.close();
+        }
+        catch (error) {
+            await storage.close();
+            db.close();
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ProjectArchive extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        force: 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>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/project/archive.js

@@ -0,0 +1,83 @@
+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, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class ProjectArchive extends PMOCommand {
+    static description = 'Archive a project (hide from default views)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> old-project',
+        '<%= config.bin %> <%= command.id %> old-project --force',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Project ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(ProjectArchive);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('project archive', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        const project = await this.storage.getProject(args.id);
+        if (!project) {
+            return handleError('PROJECT_NOT_FOUND', `Project "${args.id}" not found.`);
+        }
+        if (project.isArchived) {
+            if (jsonMode) {
+                outputErrorAsJson('ALREADY_ARCHIVED', `Project "${project.name}" is already archived.`, createMetadata('project archive', flags));
+                return;
+            }
+            this.log(styles.muted(`Project "${project.name}" is already archived.`));
+            return;
+        }
+        if (!flags.force) {
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                const confirmChoices = [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ];
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', `Archive project "${project.name}"? It will be hidden from default views.`, confirmChoices), createMetadata('project archive', flags));
+                return;
+            }
+            const { confirm } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Archive project "${project.name}"? It will be hidden from default views.`,
+                    default: false,
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        await this.storage.archiveProject(args.id);
+        this.log(styles.success(`\nArchived project "${project.name}"`));
+        this.log(styles.muted('View archived projects: prlt project list --archived'));
+        this.log(styles.muted('Unarchive: prlt project unarchive ' + args.id));
+    }
+}

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

@@ -0,0 +1,22 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class ProjectCreate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private promptProjectData;
+}

package/dist/commands/project/create.js

@@ -0,0 +1,143 @@
+import { Flags, Args } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import inquirer from 'inquirer';
+import { createBoardContent, createSpecFolders, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { slugify } from '../../lib/pmo/utils.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class ProjectCreate extends PMOCommand {
+    static description = 'Create a new project in the PMO';
+    static examples = [
+        '<%= 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',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Project name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'Project name',
+        }),
+        id: Flags.string({
+            description: 'Custom project ID (auto-generated from name if not provided)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Project description',
+        }),
+        template: Flags.string({
+            char: 't',
+            description: 'Workflow template',
+            options: ['kanban', 'linear', 'bug-smash', '5-tool-founder', 'gtm'],
+            default: 'kanban',
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(ProjectCreate);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Get project data first (before storage so prompts work)
+        let projectData;
+        if (flags.interactive || (!args.name && !flags.name)) {
+            // Build choices once - single source of truth
+            const templateChoices = [
+                { name: 'Kanban - Backlog → To Do → In Progress → Done', value: 'kanban' },
+                { name: 'Linear - Backlog, Triage, Todo, In Progress, In Review, Done', value: 'linear' },
+                { name: 'Bug Smash - Reported → Confirmed → Fixing → Verifying → Fixed', value: 'bug-smash' },
+                { name: '5-Tool Founder - Ship, Grow, Support, Strategy, BizOps → In Progress → Review → Done', value: '5-tool-founder' },
+                { name: 'GTM - Ideation → Planning → In Development → Ready to Launch → Launched', value: 'gtm' },
+            ];
+            // Define fields once - single source of truth for both JSON and interactive modes
+            const fields = [
+                { type: 'input', name: 'name', message: 'Project name:', default: flags.name },
+                { type: 'input', name: 'id', message: 'Project ID (leave blank to auto-generate):' },
+                { type: 'input', name: 'description', message: 'Description (optional):', default: flags.description },
+                { type: 'list', name: 'template', message: 'Workflow template:', choices: templateChoices, default: flags.template || 'kanban' },
+            ];
+            // In JSON mode, output form prompt for project creation
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('project create', flags));
+            }
+            projectData = await this.promptProjectData(fields);
+        }
+        else {
+            projectData = {
+                name: args.name || flags.name,
+                id: flags.id,
+                description: flags.description,
+                template: flags.template || 'kanban',
+            };
+        }
+        const projectId = projectData.id || slugify(projectData.name);
+        // Check if project already exists
+        const existing = await this.storage.getProject(projectId);
+        if (existing) {
+            this.error(`Project "${projectId}" already exists.`);
+        }
+        // Create project in database
+        const project = await this.storage.createProject({
+            id: projectId,
+            name: projectData.name,
+            description: projectData.description,
+            template: projectData.template,
+        });
+        // Create project folder structure: pmo/projects/{projectId}/
+        const projectPath = path.join(this.pmoPath, 'projects', projectId);
+        fs.mkdirSync(projectPath, { recursive: true });
+        // Create kanban.md in project directory with project name as board name
+        const boardContent = createBoardContent(projectData.template, projectData.name);
+        const boardPath = path.join(projectPath, 'kanban.md');
+        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);
+        this.log(styles.success(`\nCreated project "${styles.emphasis(project.name)}"`));
+        this.log(styles.muted(`  ID: ${project.id}`));
+        this.log(styles.muted(`  Template: ${projectData.template}`));
+        this.log(styles.muted(`  Statuses: ${statuses.map(s => s.name).join(' → ')}`));
+        this.log(styles.muted(`  Board: ${path.relative(process.cwd(), boardPath)}`));
+        this.log(styles.muted(`  Specs: ${path.relative(process.cwd(), specsPath)}/`));
+        this.log(styles.muted(`\nSwitch to this project:`));
+        this.log(styles.muted(`  prlt ticket list --project ${project.id}`));
+        this.log(styles.muted(`  prlt project view ${project.id}`));
+    }
+    async promptProjectData(fields) {
+        // Build inquirer prompts from fields, adding validators and dynamic defaults
+        const answers = await inquirer.prompt(fields.map(field => ({
+            ...field,
+            validate: field.name === 'name'
+                ? ((input) => input.length > 0 || 'Name is required')
+                : undefined,
+            // Dynamic default for id based on name
+            default: field.name === 'id'
+                ? ((answers) => slugify(answers.name))
+                : field.default,
+        })));
+        return {
+            name: answers.name,
+            id: answers.id || undefined,
+            description: answers.description || undefined,
+            template: answers.template,
+        };
+    }
+}