@proletariat/cli 0.3.96 → 0.3.98

package/dist/commands/ticket/create.js

@@ -1,760 +0,0 @@
-import { Flags } from '@oclif/core';
-import * as fs from 'node:fs';
-import inquirer from 'inquirer';
-import { autoExportToBoard, PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
-// Note: inquirer import kept for inquirer.Separator usage in interactive mode
-import { styles } from '../../lib/styles.js';
-import { updateEpicTicketsSection } from '../../lib/pmo/epic-files.js';
-import { getWorkspacePriorities } from '../../lib/work-lifecycle/settings.js';
-import { shouldOutputJson, outputErrorAsJson, outputDryRunSuccessAsJson, outputDryRunErrorsAsJson, createMetadata, } from '../../lib/prompt-json.js';
-import { FlagResolver } from '../../lib/flags/index.js';
-import { multiLineInput } from '../../lib/multiline-input.js';
-import { getRegisteredWorkSources, loadDefaultWorkSource } from '../../lib/work-source/config.js';
-export default class TicketCreate extends PMOCommand {
-    static description = 'Create a new ticket (routes to Linear when configured, or local PMO)';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --title "Fix login bug" --column Backlog',
-        '<%= config.bin %> <%= command.id %> -t "Add feature" -c "In Progress" -p P1',
-        '<%= config.bin %> <%= command.id %> --project mobile-app -t "New feature"',
-        '<%= config.bin %> <%= command.id %> --epic EPIC-001 -t "Implement auth flow"',
-        '<%= config.bin %> <%= command.id %> --title "My ticket" --description-file ./ticket-desc.md',
-        '<%= config.bin %> <%= command.id %> --title "My ticket" --description-file -  # Read from stdin',
-        '<%= config.bin %> <%= command.id %> --json  # Output column choices as JSON',
-        '<%= config.bin %> <%= command.id %> --title "Test" -P PROJ-001 --dry-run --json  # Validate without creating',
-        '<%= config.bin %> <%= command.id %> --source linear -t "Fix bug" --team ENG',
-        '<%= config.bin %> <%= command.id %> --source pmo -t "Local task" -c Backlog',
-    ];
-    static flags = {
-        ...pmoBaseFlags,
-        title: Flags.string({
-            char: 't',
-            description: 'Ticket title [required for non-interactive]',
-        }),
-        column: Flags.string({
-            char: 'c',
-            description: 'Column to place the ticket in',
-        }),
-        priority: Flags.string({
-            char: 'p',
-            description: 'Ticket priority (uses workspace priority scale)',
-        }),
-        category: Flags.string({
-            description: 'Ticket category (e.g., bug, feature, refactor)',
-        }),
-        description: Flags.string({
-            char: 'd',
-            description: 'Ticket description',
-        }),
-        'description-file': Flags.string({
-            char: 'D',
-            description: 'Path to a markdown file for the ticket description (use - for stdin)',
-            exclusive: ['description'],
-        }),
-        id: Flags.string({
-            description: 'Custom ticket ID (auto-generated if not provided)',
-        }),
-        interactive: Flags.boolean({
-            char: 'i',
-            description: 'Interactive mode',
-            default: false,
-        }),
-        epic: Flags.string({
-            char: 'e',
-            description: 'Link ticket to an epic (e.g., EPIC-001)',
-        }),
-        template: Flags.string({
-            char: 'T',
-            description: 'Create from a template (e.g., bug-report, feature-request)',
-        }),
-        labels: Flags.string({
-            char: 'l',
-            aliases: ['label'],
-            description: 'Labels (comma-separated)',
-        }),
-        'dry-run': Flags.boolean({
-            description: 'Validate inputs without creating ticket (use with --json for structured output)',
-            default: false,
-        }),
-        source: Flags.string({
-            description: 'Ticket source: "pmo" for local DB, "linear" for Linear API, or "auto" to detect (default: auto)',
-            options: ['auto', 'pmo', 'linear'],
-            default: 'auto',
-        }),
-        team: Flags.string({
-            description: 'Linear team key (fallback: PRLT_LINEAR_TEAM)',
-        }),
-    };
-    async execute() {
-        const { flags } = await this.parse(TicketCreate);
-        // Check if JSON output mode is active
-        const jsonMode = shouldOutputJson(flags);
-        // Determine ticket source (pmo, linear, or prompt user)
-        const resolvedSource = await this.resolveSource(flags, jsonMode);
-        // If Linear source is selected, delegate to the Linear creation path
-        if (resolvedSource === 'linear') {
-            return this.createLinearIssue(flags, jsonMode);
-        }
-        // PMO path — existing flow
-        // Get project and board info (pass JSON mode config for AI agents)
-        const projectId = await this.requireProject({
-            jsonMode: {
-                flags,
-                commandName: 'ticket create',
-                baseCommand: 'prlt ticket create',
-            },
-        });
-        const board = await this.storage.getBoard(projectId);
-        const columns = board.columns.map(c => c.name);
-        const projectName = await this.getProjectName(projectId);
-        // Helper to handle errors in JSON mode
-        const handleError = (code, message) => {
-            if (jsonMode) {
-                outputErrorAsJson(code, message, createMetadata('ticket create', flags));
-                return;
-            }
-            this.error(message);
-        };
-        // Read description from file if --description-file is provided
-        if (flags['description-file']) {
-            const filePath = flags['description-file'];
-            try {
-                if (filePath === '-') {
-                    // Guard: prevent hanging when no input is piped
-                    if (process.stdin.isTTY) {
-                        return handleError('DESCRIPTION_FILE_ERROR', 'Cannot read from stdin: no input piped. Use --description-file <path> with a file path instead, or pipe content via: echo "desc" | prlt ticket create --description-file -');
-                    }
-                    // Read from stdin
-                    flags.description = fs.readFileSync(0, 'utf-8');
-                }
-                else {
-                    flags.description = fs.readFileSync(filePath, 'utf-8');
-                }
-            }
-            catch (error) {
-                const errMsg = error instanceof Error ? error.message : String(error);
-                return handleError('DESCRIPTION_FILE_ERROR', `Failed to read description file "${filePath}": ${errMsg}`);
-            }
-        }
-        // Validate epic if provided
-        if (flags.epic) {
-            const epic = await this.storage.getEpic(flags.epic);
-            if (!epic) {
-                return handleError('EPIC_NOT_FOUND', `Epic not found: ${flags.epic}. Use 'prlt epic list' to see available epics.`);
-            }
-        }
-        // Load template if specified
-        let template = null;
-        if (flags.template) {
-            template = await this.storage.getTicketTemplate(flags.template);
-            if (!template) {
-                return handleError('TEMPLATE_NOT_FOUND', `Template not found: ${flags.template}. Run 'prlt ticket template list' to see available templates.`);
-            }
-        }
-        // Parse labels from flag
-        const labelsFromFlag = flags.labels
-            ? flags.labels.split(',').map(l => l.trim()).filter(Boolean)
-            : undefined;
-        // Get ticket data (interactive or from flags)
-        let ticketData;
-        // Use FlagResolver to handle both JSON mode and interactive prompts
-        // This unifies the two code paths into one pattern
-        if (!flags.interactive) {
-            // In JSON mode, default column to first backlog status if not provided
-            // This prevents prompting for column in non-interactive mode
-            if (jsonMode && !flags.column) {
-                // Prefer "Backlog" column, fall back to first column
-                const backlogColumn = columns.find(c => c.toLowerCase() === 'backlog') || columns[0];
-                flags.column = backlogColumn;
-            }
-            const resolver = new FlagResolver({
-                commandName: 'ticket create',
-                baseCommand: 'prlt ticket create',
-                jsonMode,
-                flags,
-                context: { projectId },
-            });
-            // Column selection - prompted first if missing
-            resolver.addPrompt({
-                flagName: 'column',
-                type: 'list',
-                message: 'Select column to place the ticket in:',
-                choices: () => columns.map(c => ({ name: c, value: c })),
-                when: (ctx) => !ctx.flags.column,
-            });
-            // Title input - prompted after column is set
-            resolver.addPrompt({
-                flagName: 'title',
-                type: 'input',
-                message: 'Enter ticket title:',
-                when: (ctx) => !ctx.flags.title && ctx.flags.column !== undefined,
-                validate: (value) => value.trim() ? true : 'Title cannot be empty',
-                context: (ctx) => ({
-                    hint: `Provide title with: ${ctx.baseCommand}${ctx.projectId ? ` -P ${ctx.projectId}` : ''} --column "${ctx.flags.column}" --title "Your title here"`,
-                    requiredFields: ['--title'],
-                    optionalFields: ['--priority', '--category', '--description', '--epic', '--labels'],
-                    example: `${ctx.baseCommand}${ctx.projectId ? ` -P ${ctx.projectId}` : ''} --column "${ctx.flags.column}" --title "Fix login bug" --priority P1 --category bug`,
-                }),
-            });
-            // Resolve missing flags (in JSON mode, outputs prompt and exits; in interactive mode, prompts user)
-            const resolvedFlags = await resolver.resolve();
-            // If we get here, we have both column and title
-            if (!resolvedFlags.title && !template?.titlePattern) {
-                return handleError('TITLE_REQUIRED', 'Title is required. Use --title or -t flag, or use --interactive mode.');
-            }
-            ticketData = {
-                title: resolvedFlags.title || template?.titlePattern || '',
-                statusName: resolvedFlags.column || columns[0],
-                priority: resolvedFlags.priority || template?.defaultPriority,
-                category: resolvedFlags.category || template?.defaultCategory,
-                description: resolvedFlags.description || template?.descriptionTemplate,
-                id: resolvedFlags.id,
-                epicId: resolvedFlags.epic,
-                labels: labelsFromFlag || template?.defaultLabels,
-            };
-        }
-        else {
-            // Full interactive mode - use the detailed prompts
-            ticketData = await this.promptTicketData(flags, this.storage, template, columns);
-        }
-        // Validate status/column
-        if (!columns.includes(ticketData.statusName)) {
-            if (flags['dry-run']) {
-                if (jsonMode) {
-                    outputDryRunErrorsAsJson([{ field: 'column', error: `Invalid column "${ticketData.statusName}". Available: ${columns.join(', ')}` }], createMetadata('ticket create', flags));
-                    return;
-                }
-                this.error(`Invalid column "${ticketData.statusName}". Available columns: ${columns.join(', ')}`);
-            }
-            return handleError('INVALID_COLUMN', `Invalid column "${ticketData.statusName}". Available columns: ${columns.join(', ')}`);
-        }
-        // Handle dry-run: show what would be created without actually creating
-        if (flags['dry-run']) {
-            const wouldCreate = {
-                title: ticketData.title,
-                project: projectId,
-                column: ticketData.statusName,
-                ...(ticketData.priority && { priority: ticketData.priority }),
-                ...(ticketData.category && { category: ticketData.category }),
-                ...(ticketData.description && { description: ticketData.description }),
-                ...(ticketData.epicId && { epic: ticketData.epicId }),
-                ...(ticketData.labels && ticketData.labels.length > 0 && { labels: ticketData.labels }),
-            };
-            if (jsonMode) {
-                outputDryRunSuccessAsJson('ticket', wouldCreate, createMetadata('ticket create', flags));
-                return;
-            }
-            // Human-readable dry-run output
-            this.log(styles.warning('\n[DRY RUN] Would create ticket:'));
-            this.log(styles.muted(`   Title: ${ticketData.title}`));
-            this.log(styles.muted(`   Project: ${projectName}`));
-            this.log(styles.muted(`   Column: ${ticketData.statusName}`));
-            if (ticketData.priority) {
-                this.log(styles.muted(`   Priority: ${ticketData.priority}`));
-            }
-            if (ticketData.category) {
-                this.log(styles.muted(`   Category: ${ticketData.category}`));
-            }
-            if (ticketData.epicId) {
-                this.log(styles.muted(`   Epic: ${ticketData.epicId}`));
-            }
-            if (ticketData.labels && ticketData.labels.length > 0) {
-                this.log(styles.muted(`   Labels: ${ticketData.labels.join(', ')}`));
-            }
-            if (template) {
-                this.log(styles.muted(`   Template: ${template.name}`));
-                if (template.suggestedSubtasks.length > 0) {
-                    this.log(styles.muted(`   Subtasks: ${template.suggestedSubtasks.length} would be created`));
-                }
-            }
-            this.log(styles.muted('\n(No ticket was created)'));
-            return;
-        }
-        // Create ticket through the provider (routes to configured backend)
-        const provider = this.resolveProjectProvider(projectId, 'pmo');
-        const createResult = await provider.createTicket(projectId, {
-            id: ticketData.id,
-            title: ticketData.title,
-            statusName: ticketData.statusName,
-            priority: ticketData.priority,
-            category: ticketData.category,
-            description: ticketData.description,
-            epicId: ticketData.epicId,
-            labels: ticketData.labels,
-        });
-        if (!createResult.success || !createResult.ticket) {
-            return handleError('CREATE_FAILED', `Failed to create ticket: ${createResult.error}`);
-        }
-        const ticket = createResult.ticket;
-        // Add subtasks from template if applicable
-        if (template && template.suggestedSubtasks.length > 0) {
-            // Sequential subtask creation for consistent ordering
-            for (const subtask of template.suggestedSubtasks) {
-                // eslint-disable-next-line no-await-in-loop
-                await this.storage.addSubtask(ticket.id, subtask.title);
-            }
-        }
-        // Auto-export to board.md after write
-        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
-        // If linked to an epic, update the epic's markdown file with ticket list
-        if (ticketData.epicId) {
-            const epic = await this.storage.getEpic(ticketData.epicId);
-            if (epic) {
-                const epicTickets = await this.storage.getTicketsForEpic(projectId, ticketData.epicId);
-                const ticketInfos = epicTickets.map(t => ({
-                    id: t.id,
-                    title: t.title,
-                    status: t.statusName || 'Unknown',
-                    priority: t.priority,
-                }));
-                updateEpicTicketsSection(this.pmoPath, ticketData.epicId, epic.status, ticketInfos, projectId);
-            }
-        }
-        // JSON output mode - match MCP tool response shape
-        if (jsonMode) {
-            this.log(JSON.stringify({
-                success: true,
-                ticket: {
-                    id: ticket.id,
-                    title: ticket.title,
-                    priority: ticket.priority,
-                    category: ticket.category,
-                    statusName: ticket.statusName,
-                    statusCategory: ticket.statusCategory,
-                    projectId: ticket.projectId,
-                    assignee: ticket.assignee,
-                    owner: ticket.owner,
-                    branch: ticket.branch,
-                    epicId: ticket.epicId,
-                    position: ticket.position,
-                },
-            }, null, 2));
-            return;
-        }
-        this.log(styles.success(`\n✅ Created ticket ${styles.emphasis(ticket.id)} in project ${styles.emphasis(projectName)}`));
-        if (template) {
-            this.log(styles.muted(`   Template: ${template.name}`));
-        }
-        this.log(styles.muted(`   Title: ${ticket.title}`));
-        this.log(styles.muted(`   Status: ${ticket.statusName}`));
-        if (ticket.priority) {
-            this.log(styles.muted(`   Priority: ${ticket.priority}`));
-        }
-        if (ticket.category) {
-            this.log(styles.muted(`   Category: ${ticket.category}`));
-        }
-        if (ticketData.epicId) {
-            this.log(styles.muted(`   Epic: ${ticketData.epicId}`));
-        }
-        if (ticketData.labels && ticketData.labels.length > 0) {
-            this.log(styles.muted(`   Labels: ${ticketData.labels.join(', ')}`));
-        }
-        if (template && template.suggestedSubtasks.length > 0) {
-            this.log(styles.muted(`   Subtasks: ${template.suggestedSubtasks.length} created`));
-        }
-        this.log(styles.muted(`\n   View board: prlt board`));
-        this.log(styles.muted(`   List tickets: prlt ticket list`));
-    }
-    /**
-     * Determine whether to route through Linear or PMO based on --source flag
-     * and workspace config.
-     *
-     * Resolution order for auto mode:
-     * 1. Explicit default work source (loadDefaultWorkSource) — user preference
-     * 2. Single external provider configured — auto-select it
-     * 3. Multiple external providers — prompt user to choose
-     * 4. No external providers — fall back to PMO
-     */
-    async resolveSource(flags, jsonMode) {
-        const source = flags.source || 'auto';
-        if (source === 'pmo')
-            return 'pmo';
-        if (source === 'linear')
-            return 'linear';
-        // auto: resolve from workspace config
-        const db = this.storage.getDatabase();
-        try {
-            // 1. Respect explicit default work source if configured
-            const defaultSource = loadDefaultWorkSource(db);
-            if (defaultSource?.provider === 'linear')
-                return 'linear';
-            if (defaultSource?.provider === 'pmo')
-                return 'pmo';
-            // 2. Check registered providers (PMO is always implicitly registered)
-            const registeredSources = getRegisteredWorkSources(db);
-            const externalProviders = [...new Set(registeredSources.map(s => s.provider).filter(p => p !== 'pmo'))];
-            // No external providers — use PMO
-            if (externalProviders.length === 0)
-                return 'pmo';
-            // Single external provider — auto-select it
-            if (externalProviders.length === 1) {
-                return externalProviders[0] === 'linear' ? 'linear' : 'pmo';
-            }
-            // Multiple external providers — prompt user to select
-            const allProviders = ['pmo', ...externalProviders];
-            const choices = allProviders.map(p => ({
-                name: p === 'pmo' ? 'PMO (local)' : `${p.charAt(0).toUpperCase() + p.slice(1)}`,
-                value: p,
-            }));
-            const message = 'Multiple ticket providers configured. Where should this ticket be created?';
-            const selectedSource = await this.selectFromList({
-                message,
-                items: allProviders.map(p => ({
-                    name: p === 'pmo' ? 'PMO (local)' : `${p.charAt(0).toUpperCase() + p.slice(1)}`,
-                    value: p,
-                })),
-                getName: (item) => item.name,
-                getValue: (item) => item.value,
-                getCommand: (item) => `prlt ticket create --source ${item.value} --json`,
-                jsonMode: jsonMode
-                    ? { flags: flags, commandName: 'ticket create' }
-                    : null,
-            });
-            // In JSON mode selectFromList returns null (prompt already emitted)
-            if (selectedSource === null)
-                return 'pmo';
-            // Only 'linear' gets the special path; everything else falls through to PMO
-            return selectedSource === 'linear' ? 'linear' : 'pmo';
-        }
-        catch {
-            // workspace_settings table may not exist in older/test databases
-            return 'pmo';
-        }
-    }
-    /**
-     * Create a ticket through the Linear provider adapter.
-     * Collects inputs (title, description, priority, labels) and routes
-     * through the provider, which handles the Linear API and mirror creation.
-     */
-    async createLinearIssue(flags, jsonMode) {
-        const handleError = (code, message) => {
-            if (jsonMode) {
-                outputErrorAsJson(code, message, createMetadata('ticket create', flags));
-                return;
-            }
-            this.error(message);
-        };
-        // Collect title (required)
-        let title = flags.title;
-        if (!title) {
-            const inputTitle = await this.promptForInput({
-                message: 'Enter ticket title:',
-                fieldName: 'title',
-                validate: (input) => input.trim() ? true : 'Title cannot be empty',
-                jsonMode: jsonMode
-                    ? { flags: flags, commandName: 'ticket create', commandHint: 'Provide --title flag', example: 'prlt ticket create --source linear --title "My ticket"' }
-                    : null,
-            });
-            // In JSON mode, promptForInput returns '' (prompt already emitted)
-            if (jsonMode && !inputTitle)
-                return;
-            title = inputTitle;
-        }
-        // Read description from file if --description-file is provided
-        let description = flags.description;
-        if (flags['description-file']) {
-            const filePath = flags['description-file'];
-            try {
-                if (filePath === '-') {
-                    if (process.stdin.isTTY) {
-                        return handleError('DESCRIPTION_FILE_ERROR', 'Cannot read from stdin: no input piped.');
-                    }
-                    description = fs.readFileSync(0, 'utf-8');
-                }
-                else {
-                    description = fs.readFileSync(filePath, 'utf-8');
-                }
-            }
-            catch (error) {
-                const errMsg = error instanceof Error ? error.message : String(error);
-                return handleError('DESCRIPTION_FILE_ERROR', `Failed to read description file "${filePath}": ${errMsg}`);
-            }
-        }
-        const pmoPriority = flags.priority;
-        const category = flags.category;
-        // Parse labels from flag
-        const labelsInput = flags.labels;
-        const labelNames = labelsInput
-            ? labelsInput.split(',').map(l => l.trim()).filter(Boolean)
-            : [];
-        // Handle dry-run
-        if (flags['dry-run']) {
-            const wouldCreate = {
-                source: 'linear',
-                title: title,
-                ...(description && { description }),
-                ...(pmoPriority && { priority: pmoPriority }),
-                ...(labelNames.length > 0 && { labels: labelNames }),
-                ...(category && { category }),
-            };
-            if (jsonMode) {
-                outputDryRunSuccessAsJson('ticket', wouldCreate, createMetadata('ticket create', flags));
-                return;
-            }
-            this.log(styles.warning('\n[DRY RUN] Would create Linear issue:'));
-            this.log(styles.muted(`   Title: ${title}`));
-            if (pmoPriority) {
-                this.log(styles.muted(`   Priority: ${pmoPriority}`));
-            }
-            if (labelNames.length > 0) {
-                this.log(styles.muted(`   Labels: ${labelNames.join(', ')}`));
-            }
-            if (category) {
-                this.log(styles.muted(`   Category: ${category}`));
-            }
-            if (description) {
-                const shortDesc = description.split('\n')[0].substring(0, 60);
-                this.log(styles.muted(`   Description: ${shortDesc}${description.length > 60 ? '...' : ''}`));
-            }
-            this.log(styles.muted('\n(No issue was created)'));
-            return;
-        }
-        // Get project for the provider (needed for PMO mirror)
-        const projectId = await this.requireProject({
-            jsonMode: {
-                flags: flags,
-                commandName: 'ticket create',
-                baseCommand: 'prlt ticket create --source linear',
-            },
-        });
-        // Route through provider adapter — Linear provider handles API call, mirror, and mapping
-        const provider = this.resolveProjectProvider(projectId, 'linear');
-        const createResult = await provider.createTicket(projectId, {
-            title: title,
-            description,
-            priority: pmoPriority,
-            category,
-            labels: labelNames.length > 0 ? labelNames : undefined,
-        });
-        if (!createResult.success || !createResult.ticket) {
-            return handleError('CREATE_FAILED', `Failed to create ticket: ${createResult.error}`);
-        }
-        const ticket = createResult.ticket;
-        const externalKey = ticket.metadata?.external_key;
-        const externalUrl = ticket.metadata?.external_url;
-        // JSON output
-        if (jsonMode) {
-            this.log(JSON.stringify({
-                success: true,
-                source: 'linear',
-                ticket: {
-                    id: ticket.id,
-                    title: ticket.title,
-                    priority: ticket.priority,
-                    category: ticket.category,
-                    statusName: ticket.statusName,
-                    projectId: ticket.projectId,
-                    ...(externalKey && { externalKey }),
-                    ...(externalUrl && { externalUrl }),
-                },
-            }, null, 2));
-            return;
-        }
-        this.log(styles.success(`\n✅ Created ticket ${styles.emphasis(externalKey || ticket.id)} via Linear`));
-        this.log(styles.muted(`   Title: ${ticket.title}`));
-        if (ticket.priority) {
-            this.log(styles.muted(`   Priority: ${ticket.priority}`));
-        }
-        if (externalUrl) {
-            this.log(styles.muted(`   URL: ${externalUrl}`));
-        }
-    }
-    async promptTicketData(flags, storage, existingTemplate, columns) {
-        // If no template was specified via flag, offer to select one
-        let template = existingTemplate;
-        if (!template && !flags.template) {
-            const templates = await storage.listTicketTemplates();
-            if (templates.length > 0) {
-                const { selectedTemplate } = await this.prompt([
-                    {
-                        type: 'list',
-                        name: 'selectedTemplate',
-                        message: 'Start from a template?',
-                        choices: [
-                            { name: 'No template (blank ticket)', value: '' },
-                            new inquirer.Separator('── Templates ──'),
-                            ...templates.map(t => ({
-                                name: `${t.name}${t.isBuiltin ? '' : ' [custom]'} - ${t.description || ''}`,
-                                value: t.id,
-                            })),
-                        ],
-                    },
-                ], null);
-                if (selectedTemplate) {
-                    template = templates.find(t => t.id === selectedTemplate) || null;
-                }
-            }
-        }
-        // Prompt for title
-        const { title: answerTitle } = await this.prompt([
-            {
-                type: 'input',
-                name: 'title',
-                message: 'Ticket title:',
-                default: flags.title || template?.titlePattern,
-                validate: (input) => input.trim() ? true : 'Title cannot be empty',
-            },
-        ], null);
-        // Prompt for column
-        const { column: answerColumn } = await this.prompt([
-            {
-                type: 'list',
-                name: 'column',
-                message: 'Column:',
-                choices: columns.map(c => ({ name: c, value: c })),
-                default: flags.column || columns[0],
-            },
-        ], null);
-        // Prompt for priority (using workspace priority scale)
-        const db = this.storage.getDatabase();
-        const workspacePriorities = getWorkspacePriorities(db);
-        const { priority: answerPriority } = await this.prompt([
-            {
-                type: 'list',
-                name: 'priority',
-                message: 'Priority:',
-                choices: [
-                    { name: 'None', value: undefined },
-                    ...workspacePriorities.map(p => ({ name: p, value: p })),
-                ],
-                default: flags.priority || template?.defaultPriority,
-            },
-        ], null);
-        // Prompt for category
-        const { categoryChoice } = await this.prompt([
-            {
-                type: 'list',
-                name: 'categoryChoice',
-                message: 'Category:',
-                choices: [
-                    { name: 'Skip (none)', value: '' },
-                    new inquirer.Separator('── Conventional Commits ──'),
-                    { name: 'feature     - New feature or capability', value: 'feature' },
-                    { name: 'bug         - Bug fix', value: 'bug' },
-                    { name: 'refactor    - Code refactoring', value: 'refactor' },
-                    { name: 'docs        - Documentation', value: 'docs' },
-                    { name: 'test        - Test additions/fixes', value: 'test' },
-                    { name: 'chore       - Maintenance tasks', value: 'chore' },
-                    { name: 'performance - Performance improvements', value: 'performance' },
-                    { name: 'ci          - CI/CD changes', value: 'ci' },
-                    { name: 'build       - Build system changes', value: 'build' },
-                    new inquirer.Separator('── Extended Types ──'),
-                    { name: 'security    - Security fixes', value: 'security' },
-                    { name: 'database    - Database migrations', value: 'database' },
-                    { name: 'release     - Release preparation', value: 'release' },
-                    new inquirer.Separator('── 5Tool Founder ──'),
-                    { name: 'ship        - Shipping and deployment', value: 'ship' },
-                    { name: 'growth      - Growth and marketing', value: 'growth' },
-                    { name: 'support     - Customer experience', value: 'support' },
-                    { name: 'strategy    - Strategy and planning', value: 'strategy' },
-                    { name: 'ops         - Business operations', value: 'ops' },
-                    new inquirer.Separator('───────────────────'),
-                    { name: 'Custom...', value: '__custom__' },
-                ],
-                default: flags.category || template?.defaultCategory || '',
-            },
-        ], null);
-        // Custom category prompt if needed
-        let customCategory;
-        if (categoryChoice === '__custom__') {
-            const result = await this.prompt([{
-                    type: 'input',
-                    name: 'customCategory',
-                    message: 'Enter custom category:',
-                    validate: (input) => input.trim() ? true : 'Category cannot be empty',
-                }], null);
-            customCategory = result.customCategory;
-        }
-        const answers = { title: answerTitle, column: answerColumn, priority: answerPriority, categoryChoice, customCategory };
-        // Resolve category from choice or custom input
-        const category = answers.categoryChoice === '__custom__'
-            ? answers.customCategory
-            : answers.categoryChoice || undefined;
-        // Prompt for structured description (use template description if available)
-        const description = await this.promptStructuredDescription(flags.description || template?.descriptionTemplate);
-        // Parse labels from flag or use template defaults
-        const labels = flags.labels
-            ? flags.labels.split(',').map(l => l.trim()).filter(Boolean)
-            : template?.defaultLabels;
-        return {
-            title: answers.title,
-            statusName: answers.column,
-            priority: answers.priority || undefined,
-            category,
-            description: description || undefined,
-            id: flags.id,
-            epicId: flags.epic,
-            labels,
-        };
-    }
-    async promptStructuredDescription(existingDescription) {
-        // If description already provided via flag, use it
-        if (existingDescription) {
-            return existingDescription;
-        }
-        this.log(styles.muted('\n─── Ticket Description (for agent execution) ───'));
-        // Prompt for "What" - the main outcome
-        const { what } = await this.prompt([
-            {
-                type: 'input',
-                name: 'what',
-                message: 'What is the concrete outcome? (one sentence):',
-                validate: (input) => input.trim() ? true : 'Outcome cannot be empty - what does success look like?',
-            },
-        ], null);
-        // Prompt for acceptance criteria using multiline input
-        const doneWhenResult = await multiLineInput({
-            message: 'Done when (acceptance criteria):',
-            hint: 'Enter each criterion on a new line. Ctrl+D to finish, Ctrl+C to cancel',
-        });
-        if (doneWhenResult.cancelled) {
-            throw new Error('Ticket creation cancelled');
-        }
-        // Continue with remaining prompts
-        const { context } = await this.prompt([
-            {
-                type: 'input',
-                name: 'context',
-                message: 'Context (files, patterns, hints - optional):',
-                default: '',
-            },
-        ], null);
-        const { notInScope } = await this.prompt([
-            {
-                type: 'input',
-                name: 'notInScope',
-                message: 'Not in scope (explicit exclusions - optional):',
-                default: '',
-            },
-        ], null);
-        // Build structured description
-        const parts = [];
-        parts.push(`## What\n${what}`);
-        if (doneWhenResult.value.trim()) {
-            // Ensure each line in doneWhen starts with - [ ] if it doesn't already
-            const criteria = doneWhenResult.value
-                .split('\n')
-                .map(line => line.trim())
-                .filter(line => line.length > 0)
-                .map(line => {
-                if (line.startsWith('- [ ]') || line.startsWith('- [x]')) {
-                    return line;
-                }
-                if (line.startsWith('-')) {
-                    return `- [ ]${line.slice(1)}`;
-                }
-                return `- [ ] ${line}`;
-            })
-                .join('\n');
-            parts.push(`## Done when\n${criteria}`);
-        }
-        if (context.trim()) {
-            parts.push(`## Context\n${context}`);
-        }
-        if (notInScope.trim()) {
-            parts.push(`## Not in scope\n${notInScope}`);
-        }
-        return parts.join('\n\n');
-    }
-}
-//# sourceMappingURL=create.js.map