@proletariat/cli 0.3.23 → 0.3.24

package/dist/commands/template/create.js

@@ -0,0 +1,238 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { PRIORITIES, PRIORITY_LABELS, TICKET_CATEGORIES } from '../../lib/pmo/types.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputSuccessAsJson, outputPromptAsJson, outputErrorAsJson, buildFormPromptConfig, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class TemplateCreate extends PMOCommand {
+    static description = 'Create a new template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --type ticket "Bug Report"',
+        '<%= config.bin %> <%= command.id %> --type ticket "Feature" -d "For new features"',
+        '<%= config.bin %> <%= command.id %> --type phase "My Phases"',
+        '<%= config.bin %> <%= command.id %> --type phase "Enterprise" --description "Enterprise lifecycle"',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Template name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Template type',
+            options: ['ticket', 'phase'],
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+        // Ticket-specific flags
+        'title-pattern': Flags.string({
+            description: 'Default title prefix/pattern (ticket only)',
+        }),
+        'description-template': Flags.string({
+            description: 'Default description template (ticket only)',
+        }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'Default priority (ticket only)',
+            options: [...PRIORITIES],
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'Default category (ticket only)',
+            options: [...TICKET_CATEGORIES],
+        }),
+        subtask: Flags.string({
+            description: 'Add a suggested subtask (ticket only, can repeat)',
+            multiple: true,
+        }),
+        ac: Flags.string({
+            description: 'Add an acceptance criterion (ticket only, can repeat)',
+            multiple: true,
+        }),
+        label: Flags.string({
+            char: 'l',
+            description: 'Add a default label (ticket only, can repeat)',
+            multiple: true,
+        }),
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output as JSON for AI agents/scripts',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(TemplateCreate);
+        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 create', 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.createTicketTemplate(args.name, flags, jsonMode);
+        }
+        else {
+            await this.createPhaseTemplate(args.name, flags, jsonMode);
+        }
+    }
+    async createTicketTemplate(name, flags, jsonMode) {
+        // Check if we have required data
+        if (!name) {
+            if (jsonMode) {
+                const fields = [
+                    { type: 'input', name: 'name', message: 'Template name:' },
+                    { type: 'input', name: 'description', message: 'Description (optional):' },
+                    {
+                        type: 'list',
+                        name: 'priority',
+                        message: 'Default priority:',
+                        choices: [
+                            { name: 'None', value: '' },
+                            ...PRIORITIES.map(p => ({ name: PRIORITY_LABELS[p], value: p })),
+                        ],
+                    },
+                    {
+                        type: 'list',
+                        name: 'category',
+                        message: 'Default category:',
+                        choices: [
+                            { name: 'None', value: '' },
+                            ...TICKET_CATEGORIES.map(c => ({ name: c, value: c })),
+                        ],
+                    },
+                ];
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('template create', flags));
+                return;
+            }
+            const { templateName } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'templateName',
+                    message: 'Template name:',
+                    validate: (input) => input.trim() ? true : 'Name required',
+                }]);
+            name = templateName;
+        }
+        // Get optional values
+        let description = flags.description;
+        let titlePattern = flags['title-pattern'];
+        let priority = flags.priority;
+        let category = flags.category;
+        const subtasks = flags.subtask || [];
+        const acs = flags.ac || [];
+        const labels = flags.label || [];
+        let descriptionTemplate = flags['description-template'];
+        // Interactive prompts for missing optional values
+        if (!jsonMode && description === undefined) {
+            const { desc } = await inquirer.prompt([{
+                    type: 'input', name: 'desc', message: 'Description (optional):',
+                }]);
+            description = desc || undefined;
+        }
+        if (!jsonMode && priority === undefined) {
+            const { p } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'p',
+                    message: 'Default priority:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...PRIORITIES.map(pr => ({ name: PRIORITY_LABELS[pr], value: pr })),
+                    ],
+                }]);
+            priority = p || undefined;
+        }
+        if (!jsonMode && category === undefined) {
+            const { c } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'c',
+                    message: 'Default category:',
+                    choices: [
+                        { name: 'None', value: '' },
+                        ...TICKET_CATEGORIES.map(cat => ({ name: cat, value: cat })),
+                    ],
+                }]);
+            category = c || undefined;
+        }
+        // Build description template with ACs
+        if (acs.length > 0 && !descriptionTemplate) {
+            descriptionTemplate = '## Description\n\n## Acceptance Criteria\n' +
+                acs.map(ac => `- [ ] ${ac}`).join('\n') + '\n';
+        }
+        // Create the template
+        const template = await this.storage.createTicketTemplate({
+            name: name,
+            description,
+            titlePattern,
+            defaultPriority: priority,
+            defaultCategory: category,
+            descriptionTemplate,
+            suggestedSubtasks: subtasks.map(title => ({ title })),
+            defaultLabels: labels,
+        });
+        if (jsonMode) {
+            outputSuccessAsJson({ template }, createMetadata('template create', flags));
+            return;
+        }
+        this.log(styles.success(`\nCreated ticket template "${styles.emphasis(template.name)}"`));
+        this.log(styles.muted(`  ID: ${template.id}`));
+        this.log(styles.muted(`\nApply with: prlt template apply --type ticket ${template.id}`));
+    }
+    async createPhaseTemplate(name, flags, jsonMode) {
+        if (!name) {
+            if (jsonMode) {
+                outputErrorAsJson('NAME_REQUIRED', 'Name required: prlt template create --type phase "Name"', createMetadata('template create', flags));
+                return;
+            }
+            const { templateName } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'templateName',
+                    message: 'Template name:',
+                    validate: (input) => input.trim() ? true : 'Name required',
+                }]);
+            name = templateName;
+        }
+        let description = flags.description;
+        if (!jsonMode && description === undefined) {
+            const { desc } = await inquirer.prompt([{
+                    type: 'input', name: 'desc', message: 'Description (optional):',
+                }]);
+            description = desc || undefined;
+        }
+        const template = await this.storage.savePhaseTemplate(name, description);
+        if (jsonMode) {
+            outputSuccessAsJson({
+                id: template.id,
+                name: template.name,
+                phasesCount: template.phases.length,
+            }, createMetadata('template create', flags));
+            return;
+        }
+        this.log(styles.success(`\nCreated phase template "${styles.emphasis(template.name)}" (${template.id})`));
+        this.log(styles.muted(`Saved ${template.phases.length} phases`));
+        this.log(styles.muted(`\nApply with: prlt template apply --type phase ${template.id}`));
+    }
+}

package/dist/commands/template/index.js

@@ -1,56 +1,68 @@
-import { Command } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
 import { styles } from '../../lib/styles.js';
-import { FlagResolver, shouldOutputJson } from '../../lib/flags/index.js';
-import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, buildPromptConfig, createMetadata } from '../../lib/prompt-json.js';
 export default class Template extends Command {
     static description = 'Manage templates (ticket and phase)';
     static aliases = ['templates'];
     static examples = [
-        '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> list',
         '<%= config.bin %> <%= command.id %> list --type ticket',
-        '<%= config.bin %> <%= command.id %> ticket',
-        '<%= config.bin %> <%= command.id %> phase',
+        '<%= config.bin %> <%= command.id %> create --type ticket "Bug Report"',
+        '<%= config.bin %> <%= command.id %> apply --type phase agile',
     ];
     static flags = {
-        ...machineOutputFlags,
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output as JSON for AI agents/scripts',
+            default: false,
+        }),
     };
     async run() {
         const { flags } = await this.parse(Template);
         const jsonMode = shouldOutputJson(flags);
-        // Create resolver for action selection
-        const resolver = new FlagResolver({
-            commandName: 'template',
-            baseCommand: 'prlt template',
-            jsonMode,
-            flags: {},
-        });
-        resolver.addPrompt({
-            flagName: 'action',
-            type: 'list',
-            message: 'What would you like to do?',
-            choices: () => [
-                { name: 'List all templates', value: 'list', command: 'prlt template list --json' },
-                { name: 'Ticket templates (ticket presets)', value: 'ticket', command: 'prlt template ticket --json' },
-                { name: 'Phase templates (project phases)', value: 'phase', command: 'prlt template phase --json' },
-            ],
-        });
-        // In JSON mode, this outputs the prompt and exits
-        // In interactive mode, this prompts and returns the value
-        const resolved = await resolver.resolve();
-        // Only reached in interactive mode
-        this.log('');
-        this.log(styles.header('Templates'));
-        this.log('');
-        switch (resolved.action) {
+        const menuChoices = [
+            { name: 'List templates', value: 'list', command: 'prlt template list --json' },
+            { name: 'Create template', value: 'create', command: 'prlt template create --json' },
+            { name: 'Apply template', value: 'apply', command: 'prlt template apply --json' },
+            { name: 'Save ticket as template', value: 'save', command: 'prlt template save --json' },
+            { name: 'Update phase template', value: 'update', command: 'prlt template update --json' },
+            { name: 'Delete template', value: 'delete', command: 'prlt template delete --json' },
+            { name: 'Cancel', value: 'cancel', command: '' },
+        ];
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', 'What would you like to do?', menuChoices), createMetadata('template', flags));
+            return;
+        }
+        this.log(`\n${styles.emphasis('Templates')}`);
+        this.log(styles.muted('Manage ticket and phase templates\n'));
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: menuChoices.map(c => ({ name: c.name, value: c.value })),
+            }]);
+        if (action === 'cancel')
+            return;
+        switch (action) {
             case 'list':
                 await this.config.runCommand('template:list', []);
                 break;
-            case 'ticket':
-                await this.config.runCommand('template:ticket', []);
+            case 'create':
+                await this.config.runCommand('template:create', []);
+                break;
+            case 'apply':
+                await this.config.runCommand('template:apply', []);
+                break;
+            case 'save':
+                await this.config.runCommand('template:save', []);
+                break;
+            case 'update':
+                await this.config.runCommand('template:update', []);
                 break;
-            case 'phase':
-                await this.config.runCommand('template:phase', []);
+            case 'delete':
+                await this.config.runCommand('template:delete', []);
                 break;
         }
     }

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

@@ -1,5 +1,5 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
-export default class TicketTemplateSave extends PMOCommand {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TemplateSave extends PMOCommand {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/template/save.js

@@ -0,0 +1,104 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class TemplateSave extends PMOCommand {
+    static description = 'Create a ticket template from an existing ticket';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TKT-001 "Bug Report Template"',
+        '<%= config.bin %> <%= command.id %> TKT-042 "Feature Request" -d "Standard feature request"',
+    ];
+    static args = {
+        ticket: Args.string({
+            description: 'Ticket ID to create template from',
+            required: false,
+        }),
+        name: Args.string({
+            description: 'Template name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        'template-name': Flags.string({
+            char: 'n',
+            description: 'Template name (alternative to positional arg)',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+        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(TemplateSave);
+        const jsonMode = shouldOutputJson(flags);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('template save', flags));
+            }
+            this.error(message);
+        };
+        // Get ticket ID
+        let ticketId = args.ticket;
+        if (!ticketId) {
+            const projectId = await this.requireProject();
+            const tickets = await this.storage.listTickets(projectId);
+            if (tickets.length === 0) {
+                return handleError('NO_TICKETS', 'No tickets found. Create a ticket first.');
+            }
+            if (jsonMode) {
+                const choices = tickets.slice(0, 20).map(t => ({ name: `${t.id} - ${t.title}`, value: t.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'ticket', 'Select ticket:', choices), createMetadata('template save', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select ticket:',
+                    choices: tickets.slice(0, 20).map(t => ({ name: `${t.id} - ${t.title}`, value: t.id })),
+                }]);
+            ticketId = selected;
+        }
+        const ticket = await this.storage.getTicket(ticketId);
+        if (!ticket) {
+            return handleError('TICKET_NOT_FOUND', `Ticket not found: ${ticketId}`);
+        }
+        // Get template name
+        let templateName = flags['template-name'] || args.name;
+        if (!templateName) {
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('input', 'name', 'Template name:', undefined, ticket.category || ticket.title.split(' ')[0]), createMetadata('template save', flags));
+                return;
+            }
+            const { name } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'name',
+                    message: 'Template name:',
+                    default: ticket.category || ticket.title.split(' ')[0],
+                    validate: (i) => i.length > 0 || 'Required',
+                }]);
+            templateName = name;
+        }
+        // Get description
+        let description = flags.description;
+        if (description === undefined && !jsonMode) {
+            const { desc } = await inquirer.prompt([{ type: 'input', name: 'desc', message: 'Description (optional):' }]);
+            description = desc || undefined;
+        }
+        const template = await this.storage.createTicketTemplateFromTicket(ticketId, templateName, description);
+        if (jsonMode) {
+            outputSuccessAsJson({ template, sourceTicketId: ticketId }, createMetadata('template save', flags));
+            return;
+        }
+        this.log(styles.success(`\nCreated template "${styles.emphasis(template.name)}" from ${ticketId}`));
+        this.log(styles.muted(`  ID: ${template.id}`));
+        this.log(styles.muted(`\nApply with: prlt template apply --type ticket ${template.id}`));
+    }
+}

package/dist/commands/{phase/template → template}/update.d.ts

@@ -1,5 +1,5 @@
-import { PMOCommand } from '../../../lib/pmo/index.js';
-export default class PhaseTemplateUpdate extends PMOCommand {
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TemplateUpdate extends PMOCommand {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/template/update.js

@@ -0,0 +1,99 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class TemplateUpdate extends PMOCommand {
+    static description = 'Update a phase template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-template --name "New Name"',
+        '<%= config.bin %> <%= command.id %> my-template -d "Updated description"',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Template ID to update',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'New template name',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'New template description',
+        }),
+        json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
+            description: 'Output as JSON for AI agents/scripts',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(TemplateUpdate);
+        const jsonMode = shouldOutputJson(flags);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('template update', flags));
+            }
+            this.error(message);
+        };
+        // Get template ID
+        let templateId = args.id;
+        if (!templateId) {
+            const templates = await this.storage.listPhaseTemplates();
+            const editable = templates.filter(t => !t.isBuiltin);
+            if (editable.length === 0) {
+                return handleError('NO_TEMPLATES', 'No editable phase templates (built-in cannot be updated).');
+            }
+            if (jsonMode) {
+                const choices = editable.map(t => ({ name: `${t.name}${t.description ? ` - ${t.description}` : ''}`, value: t.id }));
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select template:', choices), createMetadata('template update', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select template:',
+                    choices: editable.map(t => ({ name: `${t.name}${t.description ? ` - ${t.description}` : ''}`, value: t.id })),
+                }]);
+            templateId = selected;
+        }
+        // Get updates
+        let newName = flags.name;
+        let newDescription = flags.description;
+        if (!newName && newDescription === undefined && !jsonMode) {
+            const { updateName } = await inquirer.prompt([{
+                    type: 'input', name: 'updateName', message: 'New name (leave empty to keep):',
+                }]);
+            if (updateName)
+                newName = updateName;
+            const { updateDesc } = await inquirer.prompt([{
+                    type: 'input', name: 'updateDesc', message: 'New description (leave empty to keep):',
+                }]);
+            if (updateDesc)
+                newDescription = updateDesc;
+            if (!newName && !newDescription) {
+                this.log(styles.muted('No changes.'));
+                return;
+            }
+        }
+        const changes = {};
+        if (newName)
+            changes.name = newName;
+        if (newDescription !== undefined)
+            changes.description = newDescription;
+        const template = await this.storage.updatePhaseTemplate(templateId, changes);
+        if (jsonMode) {
+            outputSuccessAsJson({ template }, createMetadata('template update', flags));
+            return;
+        }
+        this.log(styles.success(`\nUpdated template "${styles.emphasis(template.name)}"`));
+    }
+}

package/dist/commands/{agent/themes → theme}/add-names.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class ThemesAddNames extends Command {
+export default class ThemeAddNames extends Command {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{agent/themes → theme}/add-names.js

@@ -1,9 +1,9 @@
 import { Command, Args } from '@oclif/core';
 import chalk from 'chalk';
-import { getWorkspaceInfo } from '../../../lib/agents/commands.js';
-import { isValidAgentName, normalizeAgentName } from '../../../lib/themes.js';
-import { getTheme, addThemeNames, getThemeNames } from '../../../lib/database/index.js';
-export default class ThemesAddNames extends Command {
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { isValidAgentName, normalizeAgentName } from '../../lib/themes.js';
+import { getTheme, addThemeNames, getThemeNames } from '../../lib/database/index.js';
+export default class ThemeAddNames extends Command {
     static description = 'Add names to a theme';
     static examples = [
         '<%= config.bin %> <%= command.id %> greek-gods zeus athena poseidon',
@@ -21,13 +21,13 @@ export default class ThemesAddNames extends Command {
     };
     static strict = false; // Allow multiple name arguments
     async run() {
-        const { args, argv } = await this.parse(ThemesAddNames);
+        const { args, argv } = await this.parse(ThemeAddNames);
         try {
             const workspaceInfo = getWorkspaceInfo();
             // Validate theme exists
             const theme = getTheme(workspaceInfo.path, args.theme);
             if (!theme) {
-                this.error(`Theme "${args.theme}" not found. Run "prlt agent themes list" to see available themes.`);
+                this.error(`Theme "${args.theme}" not found. Run "prlt theme list" to see available themes.`);
             }
             // Get names from remaining arguments (skip the theme arg)
             const rawNames = argv.slice(1);

package/dist/commands/{agent/themes → theme}/create.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class ThemesCreate extends Command {
+export default class ThemeCreate extends Command {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/{agent/themes → theme}/create.js

@@ -1,8 +1,8 @@
 import { Command, Args, Flags } from '@oclif/core';
 import chalk from 'chalk';
-import { getWorkspaceInfo } from '../../../lib/agents/commands.js';
-import { createTheme, getTheme } from '../../../lib/database/index.js';
-export default class ThemesCreate extends Command {
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { createTheme, getTheme } from '../../lib/database/index.js';
+export default class ThemeCreate extends Command {
     static description = 'Create a custom agent theme';
     static examples = [
         '<%= config.bin %> <%= command.id %> greek-gods',
@@ -25,7 +25,7 @@ export default class ThemesCreate extends Command {
         }),
     };
     async run() {
-        const { args, flags } = await this.parse(ThemesCreate);
+        const { args, flags } = await this.parse(ThemeCreate);
         try {
             const workspaceInfo = getWorkspaceInfo();
             // Validate theme name format
@@ -57,7 +57,7 @@ export default class ThemesCreate extends Command {
                 this.log(chalk.gray(`   ${theme.description}`));
             }
             this.log('');
-            this.log(chalk.blue('Add names with: prlt agent themes add-names ' + name + ' <names...>'));
+            this.log(chalk.blue('Add names with: prlt theme add-names ' + name + ' <names...>'));
         }
         catch (error) {
             this.error(error instanceof Error ? error.message : String(error));

package/dist/commands/{agent/themes → theme}/index.d.ts

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class Themes extends Command {
+export default class Theme extends Command {
     static description: string;
     static examples: string[];
     static flags: {