@proletariat/cli 0.3.23 → 0.3.25

package/dist/commands/support/issues.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class SupportIssues extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        browser: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private openUrl;
+}

package/dist/commands/support/issues.js

@@ -0,0 +1,77 @@
+import { Command, Flags } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import { styles } from '../../lib/styles.js';
+import { isMachineOutput, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { SUPPORT_URLS } from './index.js';
+export default class SupportIssues extends Command {
+    static description = 'Browse GitHub Issues';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --browser',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+        browser: Flags.boolean({
+            description: 'Open issues in browser (default behavior)',
+            default: true,
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SupportIssues);
+        const url = SUPPORT_URLS.issues;
+        // In JSON mode, return the URL
+        if (isMachineOutput(flags)) {
+            outputSuccessAsJson({
+                action: 'issues',
+                url,
+                message: 'Browse GitHub Issues',
+            }, createMetadata('support issues', flags));
+            return;
+        }
+        // Open in browser (default)
+        if (flags.browser) {
+            this.openUrl(url);
+            this.log(styles.success('Opening GitHub Issues...'));
+            this.log(styles.muted(`URL: ${url}`));
+        }
+        else {
+            // List issues via gh CLI when --no-browser is set
+            try {
+                const output = execSync('gh issue list --repo chrismcdermut/proletariat', {
+                    encoding: 'utf-8',
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                this.log(styles.header('Open Issues'));
+                this.log(output.trim() || styles.muted('No open issues found.'));
+            }
+            catch {
+                this.log(styles.warning('Could not list issues via gh CLI.'));
+                this.log(styles.info(`Please visit: ${url}`));
+            }
+        }
+    }
+    openUrl(url) {
+        const platform = process.platform;
+        try {
+            if (platform === 'darwin') {
+                execSync(`open "${url}"`);
+            }
+            else if (platform === 'linux') {
+                execSync(`xdg-open "${url}"`);
+            }
+            else if (platform === 'win32') {
+                execSync(`start "" "${url}"`);
+            }
+            else {
+                throw new Error(`Unsupported platform: ${platform}`);
+            }
+        }
+        catch {
+            this.log(styles.warning('Could not open browser automatically.'));
+            this.log(styles.info(`Please visit: ${url}`));
+        }
+    }
+}

package/dist/commands/support/logs.d.ts

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SupportLogs extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        clipboard: 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 execute(): Promise<void>;
+    private collectDiagnostics;
+    private checkGh;
+    private checkDocker;
+    private checkTmux;
+    private getWorkspaceInfo;
+    private formatDiagnostics;
+    private copyToClipboard;
+}

package/dist/commands/support/logs.js

@@ -0,0 +1,247 @@
+import { Flags } from '@oclif/core';
+import * as os from 'node:os';
+import { execSync } from 'node:child_process';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { isMachineOutput, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class SupportLogs extends PMOCommand {
+    static description = 'Collect diagnostic info for troubleshooting';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --clipboard',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        clipboard: Flags.boolean({
+            description: 'Copy diagnostics to clipboard',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(SupportLogs);
+        const diagnostics = await this.collectDiagnostics();
+        // In JSON mode, return structured object
+        if (isMachineOutput(flags)) {
+            outputSuccessAsJson(diagnostics, createMetadata('support logs', flags));
+            return;
+        }
+        // Format as readable text
+        const text = this.formatDiagnostics(diagnostics);
+        // Copy to clipboard if requested
+        if (flags.clipboard) {
+            const copied = this.copyToClipboard(text);
+            if (copied) {
+                this.log(styles.success('Diagnostics copied to clipboard!'));
+                this.log('');
+            }
+        }
+        // Display diagnostics
+        this.log(text);
+    }
+    async collectDiagnostics() {
+        const diagnostics = {
+            prlt: {
+                version: this.config.version,
+            },
+            node: {
+                version: process.version,
+            },
+            os: {
+                platform: process.platform,
+                release: os.release(),
+                arch: os.arch(),
+            },
+            shell: process.env.SHELL,
+            tools: {
+                gh: this.checkGh(),
+                docker: this.checkDocker(),
+                tmux: this.checkTmux(),
+            },
+        };
+        // Add workspace info if available
+        try {
+            const workspaceInfo = await this.getWorkspaceInfo();
+            if (workspaceInfo) {
+                diagnostics.workspace = workspaceInfo;
+            }
+        }
+        catch {
+            // PMO may not be initialized
+        }
+        return diagnostics;
+    }
+    checkGh() {
+        try {
+            const versionOutput = execSync('gh --version', {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const version = versionOutput.split('\n')[0]?.replace('gh version ', '').trim();
+            let authenticated = false;
+            try {
+                execSync('gh auth status', { stdio: 'ignore' });
+                authenticated = true;
+            }
+            catch {
+                authenticated = false;
+            }
+            return { installed: true, version, authenticated };
+        }
+        catch {
+            return { installed: false };
+        }
+    }
+    checkDocker() {
+        try {
+            execSync('docker --version', { stdio: 'ignore' });
+            let running = false;
+            try {
+                execSync('docker info', { stdio: 'ignore' });
+                running = true;
+            }
+            catch {
+                running = false;
+            }
+            return { installed: true, running };
+        }
+        catch {
+            return { installed: false };
+        }
+    }
+    checkTmux() {
+        try {
+            const versionOutput = execSync('tmux -V', {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const version = versionOutput.trim();
+            return { installed: true, version };
+        }
+        catch {
+            return { installed: false };
+        }
+    }
+    async getWorkspaceInfo() {
+        try {
+            const projects = await this.storage.listProjects();
+            let totalTickets = 0;
+            for (const project of projects) {
+                // eslint-disable-next-line no-await-in-loop
+                const tickets = await this.storage.listTickets(project.id);
+                totalTickets += tickets.length;
+            }
+            // Get agents count by checking for agents directory
+            let agentCount = 0;
+            try {
+                const { getWorkspaceInfo } = await import('../../lib/agents/commands.js');
+                const wsInfo = getWorkspaceInfo();
+                agentCount = wsInfo.agents?.length || 0;
+            }
+            catch {
+                // Agents module may not be available
+            }
+            return {
+                path: this.pmoPath,
+                name: projects[0]?.name,
+                repoCount: projects.length,
+                agentCount,
+                ticketCount: totalTickets,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    formatDiagnostics(d) {
+        const lines = [];
+        lines.push(styles.title('Diagnostic Information'));
+        lines.push('');
+        // System info
+        lines.push(styles.header('System'));
+        lines.push(`  prlt version:   ${d.prlt.version}`);
+        lines.push(`  Node version:   ${d.node.version}`);
+        lines.push(`  OS:             ${d.os.platform} ${d.os.release} (${d.os.arch})`);
+        lines.push(`  Shell:          ${d.shell || 'unknown'}`);
+        lines.push('');
+        // Tools
+        lines.push(styles.header('Tools'));
+        // gh
+        if (d.tools.gh.installed) {
+            const authStatus = d.tools.gh.authenticated ? styles.success('authenticated') : styles.warning('not authenticated');
+            lines.push(`  gh CLI:         ${styles.success('installed')} (${d.tools.gh.version}) - ${authStatus}`);
+        }
+        else {
+            lines.push(`  gh CLI:         ${styles.warning('not installed')}`);
+        }
+        // docker
+        if (d.tools.docker.installed) {
+            const runStatus = d.tools.docker.running ? styles.success('running') : styles.warning('not running');
+            lines.push(`  Docker:         ${styles.success('installed')} - ${runStatus}`);
+        }
+        else {
+            lines.push(`  Docker:         ${styles.warning('not installed')}`);
+        }
+        // tmux
+        if (d.tools.tmux.installed) {
+            lines.push(`  tmux:           ${styles.success('installed')} (${d.tools.tmux.version})`);
+        }
+        else {
+            lines.push(`  tmux:           ${styles.muted('not installed')}`);
+        }
+        lines.push('');
+        // Workspace
+        if (d.workspace) {
+            lines.push(styles.header('Workspace'));
+            lines.push(`  Path:           ${d.workspace.path}`);
+            if (d.workspace.name) {
+                lines.push(`  Name:           ${d.workspace.name}`);
+            }
+            lines.push(`  Projects:       ${d.workspace.repoCount ?? 0}`);
+            lines.push(`  Agents:         ${d.workspace.agentCount ?? 0}`);
+            lines.push(`  Tickets:        ${d.workspace.ticketCount ?? 0}`);
+        }
+        else {
+            lines.push(styles.header('Workspace'));
+            lines.push(styles.muted('  No workspace initialized'));
+        }
+        return lines.join('\n');
+    }
+    copyToClipboard(text) {
+        const platform = process.platform;
+        // Strip ANSI codes for clipboard
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional ANSI escape code stripping
+        const plainText = text.replace(/\x1b\[[0-9;]*m/g, '');
+        try {
+            if (platform === 'darwin') {
+                execSync('pbcopy', { input: plainText, encoding: 'utf-8' });
+                return true;
+            }
+            else if (platform === 'linux') {
+                // Try xclip first, then xsel
+                try {
+                    execSync('xclip -selection clipboard', { input: plainText, encoding: 'utf-8' });
+                    return true;
+                }
+                catch {
+                    try {
+                        execSync('xsel --clipboard --input', { input: plainText, encoding: 'utf-8' });
+                        return true;
+                    }
+                    catch {
+                        this.log(styles.warning('Install xclip or xsel to enable clipboard support.'));
+                        return false;
+                    }
+                }
+            }
+            else if (platform === 'win32') {
+                execSync('clip', { input: plainText, encoding: 'utf-8' });
+                return true;
+            }
+        }
+        catch {
+            this.log(styles.warning('Could not copy to clipboard.'));
+        }
+        return false;
+    }
+}

package/dist/commands/{ticket/template → template}/apply.d.ts

@@ -1,25 +1,27 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
-export default class TicketTemplateApply extends PMOCommand {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TemplateApply extends PMOCommand {
     static description: string;
     static examples: string[];
     static args: {
         template: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         title: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         column: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         priority: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         category: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         assignee: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         owner: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        labels: 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>;
+        epic: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-subtasks': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        'no-subtasks': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        epic: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     execute(): Promise<void>;
+    private applyTicketTemplate;
+    private applyPhaseTemplate;
 }

package/dist/commands/template/apply.js

@@ -0,0 +1,262 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags, autoExportToBoard } from '../../lib/pmo/index.js';
+import { PRIORITIES, PRIORITY_LABELS } from '../../lib/pmo/types.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildFormPromptConfig, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class TemplateApply extends PMOCommand {
+    static description = 'Apply a template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --type ticket bug-report',
+        '<%= config.bin %> <%= command.id %> --type ticket bug-report --title "Login fails"',
+        '<%= config.bin %> <%= command.id %> --type phase agile',
+        '<%= config.bin %> <%= command.id %> --type phase default --force',
+    ];
+    static args = {
+        template: Args.string({
+            description: 'Template ID to apply',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Template type',
+            options: ['ticket', 'phase'],
+        }),
+        // Ticket-specific flags
+        title: Flags.string({
+            description: 'Ticket title (ticket only)',
+        }),
+        column: Flags.string({
+            char: 'c',
+            description: 'Column to place ticket (ticket only)',
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'Priority override (ticket only)',
+            options: [...PRIORITIES],
+        }),
+        category: Flags.string({
+            description: 'Category override (ticket only)',
+        }),
+        assignee: Flags.string({
+            char: 'a',
+            description: 'Assignee (ticket only)',
+        }),
+        owner: Flags.string({
+            char: 'o',
+            description: 'Owner (ticket only)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Description override (ticket only)',
+        }),
+        epic: Flags.string({
+            char: 'e',
+            description: 'Link to epic (ticket only)',
+        }),
+        'no-subtasks': Flags.boolean({
+            description: 'Skip creating subtasks (ticket only)',
+            default: false,
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode (ticket only)',
+            default: false,
+        }),
+        // Phase-specific flags
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation (phase only)',
+            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(TemplateApply);
+        const jsonMode = shouldOutputJson(flags);
+        // Determine template type
+        let templateType = flags.type;
+        if (!templateType) {
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'type', 'What type of template?', [
+                    { name: 'Ticket template', value: 'ticket' },
+                    { name: 'Phase template', value: 'phase' },
+                ]), createMetadata('template apply', flags));
+                return;
+            }
+            const { selectedType } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedType',
+                    message: 'What type of template?',
+                    choices: [
+                        { name: 'Ticket template', value: 'ticket' },
+                        { name: 'Phase template', value: 'phase' },
+                    ],
+                }]);
+            templateType = selectedType;
+        }
+        if (templateType === 'ticket') {
+            await this.applyTicketTemplate(args.template, flags, jsonMode);
+        }
+        else {
+            await this.applyPhaseTemplate(args.template, flags, jsonMode);
+        }
+    }
+    async applyTicketTemplate(templateId, flags, jsonMode) {
+        const projectId = await this.requireProject();
+        const board = await this.storage.getBoard(projectId);
+        const columns = board.columns.map(col => col.name);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('template apply', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get template
+        if (!templateId) {
+            const templates = await this.storage.listTicketTemplates();
+            if (templates.length === 0) {
+                return handleError('NO_TEMPLATES', 'No ticket templates. Create with: prlt template create --type ticket');
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select template:',
+                    choices: templates.map(t => ({ name: `${t.name}${t.description ? ` - ${t.description}` : ''}`, value: t.id })),
+                }]);
+            templateId = selected;
+        }
+        const template = await this.storage.getTicketTemplate(templateId);
+        if (!template) {
+            return handleError('TEMPLATE_NOT_FOUND', `Template not found: ${templateId}`);
+        }
+        // Determine ticket data
+        let title = flags.title || template.titlePattern || '';
+        let column = flags.column || columns[0];
+        let priority = flags.priority || template.defaultPriority;
+        let category = flags.category || template.defaultCategory;
+        let assignee = flags.assignee || template.defaultAssignee;
+        let owner = flags.owner || template.defaultOwner;
+        let description = flags.description || template.descriptionTemplate;
+        const labels = template.defaultLabels;
+        // Interactive mode
+        if (flags.interactive || !title) {
+            const fields = [
+                { type: 'input', name: 'title', message: 'Title:', default: title || undefined },
+                { type: 'list', name: 'column', message: 'Column:', choices: columns.map(c => ({ name: c, value: c })), default: column },
+                { type: 'list', name: 'priority', message: 'Priority:', choices: [{ name: 'None', value: '' }, ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p }))], default: priority },
+            ];
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('template apply', flags));
+                return;
+            }
+            const answers = await inquirer.prompt(fields.map(f => ({
+                ...f,
+                validate: f.name === 'title' ? ((i) => i.length > 0 || 'Required') : undefined,
+            })));
+            title = answers.title;
+            column = answers.column;
+            priority = answers.priority || undefined;
+        }
+        // Validate epic if provided
+        if (flags.epic) {
+            const epic = await this.storage.getEpic(flags.epic);
+            if (!epic)
+                this.error(`Epic not found: ${flags.epic}`);
+        }
+        // Create ticket
+        const ticket = await this.storage.createTicket(projectId, {
+            title,
+            statusName: column,
+            priority,
+            category,
+            assignee,
+            owner,
+            labels,
+            description,
+            epicId: flags.epic,
+        });
+        // Add subtasks
+        if (!flags['no-subtasks'] && template.suggestedSubtasks.length > 0) {
+            for (const subtask of template.suggestedSubtasks) {
+                await this.storage.addSubtask(ticket.id, subtask.title);
+            }
+        }
+        await autoExportToBoard(this.pmoPath, this.storage, (msg) => this.log(styles.muted(msg)));
+        this.log(styles.success(`\nCreated ticket ${styles.emphasis(ticket.id)} from template "${template.name}"`));
+        this.log(styles.muted(`  Title: ${ticket.title}`));
+        this.log(styles.muted(`  Status: ${ticket.statusName}`));
+        if (priority)
+            this.log(styles.muted(`  Priority: ${priority}`));
+        if (template.suggestedSubtasks.length > 0 && !flags['no-subtasks']) {
+            this.log(styles.muted(`  Subtasks: ${template.suggestedSubtasks.length} created`));
+        }
+    }
+    async applyPhaseTemplate(templateId, flags, jsonMode) {
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('template apply', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get template
+        if (!templateId) {
+            const templates = await this.storage.listPhaseTemplates();
+            if (templates.length === 0) {
+                return handleError('NO_TEMPLATES', 'No phase templates. Create with: prlt template create --type phase');
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select phase template:',
+                    choices: templates.map(t => ({ name: `${t.name}${t.description ? ` - ${t.description}` : ''}`, value: t.id })),
+                }]);
+            templateId = selected;
+        }
+        const template = await this.storage.getPhaseTemplate(templateId);
+        if (!template) {
+            return handleError('TEMPLATE_NOT_FOUND', `Template not found: ${templateId}`);
+        }
+        // Check existing phases
+        const existingPhases = await this.storage.listPhases();
+        if (existingPhases.length > 0 && !flags.force) {
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', `Replace ${existingPhases.length} existing phase(s)?`, [
+                    { name: 'No', value: 'false' },
+                    { name: 'Yes', value: 'true' },
+                ]), createMetadata('template apply', flags));
+                return;
+            }
+            this.log(styles.warning(`\nThis will REPLACE ${existingPhases.length} existing phase(s).`));
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: `Apply template "${template.name}"?`,
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes', value: true },
+                    ],
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled'));
+                return;
+            }
+        }
+        const phases = await this.storage.applyPhaseTemplate(templateId);
+        this.log(styles.success(`\nApplied phase template "${styles.emphasis(template.name)}"`));
+        this.log(styles.muted(`Created ${phases.length} phases:`));
+        for (const phase of phases) {
+            this.log(styles.muted(`  • ${phase.name} [${phase.category}]`));
+        }
+    }
+}

package/dist/commands/{ticket/template → template}/create.d.ts

@@ -1,11 +1,12 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
-export default class TicketTemplateCreate extends PMOCommand {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TemplateCreate extends PMOCommand {
     static description: string;
     static examples: string[];
     static args: {
         name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        type: 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>;
         'title-pattern': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'description-template': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -21,8 +22,6 @@ export default class TicketTemplateCreate extends PMOCommand {
         promptIfMultiple: boolean;
     };
     execute(): Promise<void>;
-    /**
-     * Check if any non-default flags were provided (indicating non-interactive intent)
-     */
-    private hasNonDefaultFlags;
+    private createTicketTemplate;
+    private createPhaseTemplate;
 }