@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/template/delete.js

@@ -0,0 +1,142 @@
+import { Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class TemplateDelete extends PMOCommand {
+    static description = 'Delete templates (ticket or phase)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --type ticket',
+        '<%= config.bin %> <%= command.id %> --type phase',
+        '<%= config.bin %> <%= command.id %> --force',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Template type to delete',
+            options: ['ticket', 'phase'],
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(TemplateDelete);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // If no type specified, prompt for type first
+        let templateType = flags.type;
+        if (!templateType) {
+            const typeChoices = [
+                { name: 'Ticket templates', value: 'ticket' },
+                { name: 'Phase templates', value: 'phase' },
+            ];
+            const typeMessage = 'Which template type would you like to delete?';
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'type', typeMessage, typeChoices), createMetadata('template delete', flags));
+                return;
+            }
+            const { selectedType } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedType',
+                    message: typeMessage,
+                    choices: typeChoices,
+                }]);
+            templateType = selectedType;
+        }
+        // Get custom templates of the selected type
+        let templates = [];
+        let typeName = '';
+        switch (templateType) {
+            case 'ticket': {
+                typeName = 'ticket';
+                const ticketTemplates = await this.storage.listTicketTemplates({ isBuiltin: false });
+                templates = ticketTemplates.map(t => ({ id: t.id, name: t.name }));
+                break;
+            }
+            case 'phase': {
+                typeName = 'phase';
+                const phaseTemplates = await this.storage.listPhaseTemplates({ isBuiltin: false });
+                templates = phaseTemplates.map(t => ({ id: t.id, name: t.name }));
+                break;
+            }
+        }
+        if (templates.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_TEMPLATES', `No custom ${typeName} templates to delete.`, createMetadata('template delete', flags));
+                this.exit(1);
+            }
+            this.log(styles.muted(`\nNo custom ${typeName} templates to delete.`));
+            return;
+        }
+        // Build choices for template selection
+        const templateChoices = templates.map(t => ({
+            name: t.name,
+            value: t.id,
+        }));
+        const message = `Select ${typeName} templates to delete:`;
+        // In JSON mode, output template selection prompt
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('checkbox', 'templateIds', message, templateChoices), createMetadata('template delete', flags));
+            return;
+        }
+        // Select templates to delete
+        const { selected } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selected',
+                message,
+                choices: templateChoices,
+            }]);
+        if (selected.length === 0) {
+            this.log(styles.muted('\nNo templates selected.'));
+            return;
+        }
+        // Confirm deletion
+        if (!flags.force) {
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: `Delete ${selected.length} ${typeName} template(s)?`,
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes', value: true },
+                    ],
+                    default: 0,
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        // Delete selected templates
+        let deleted = 0;
+        for (const id of selected) {
+            try {
+                switch (templateType) {
+                    case 'ticket':
+                        await this.storage.deleteTicketTemplate(id);
+                        break;
+                    case 'phase':
+                        await this.storage.deletePhaseTemplate(id);
+                        break;
+                }
+                deleted++;
+            }
+            catch (error) {
+                this.warn(`Failed to delete "${id}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.log(styles.success(`\nDeleted ${deleted} ${typeName} template(s)`));
+    }
+}

package/dist/commands/template/index.d.ts

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

package/dist/commands/template/index.js

@@ -0,0 +1,64 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } 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',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Template);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        const menuChoices = [
+            { name: 'List all templates', value: 'list' },
+            new inquirer.Separator(),
+            { name: 'Ticket templates (ticket presets)', value: 'ticket' },
+            { name: 'Phase templates (project phases)', value: 'phase' },
+        ];
+        const message = 'What would you like to do?';
+        // In JSON mode, output menu prompt (without separators)
+        if (jsonMode) {
+            const jsonChoices = [
+                { name: 'List all templates', value: 'list' },
+                { name: 'Ticket templates (ticket presets)', value: 'ticket' },
+                { name: 'Phase templates (project phases)', value: 'phase' },
+            ];
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, jsonChoices), createMetadata('template', flags));
+            return;
+        }
+        this.log('');
+        this.log(styles.header('Templates'));
+        this.log('');
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message,
+                choices: menuChoices,
+            }]);
+        switch (action) {
+            case 'list':
+                await this.config.runCommand('template:list', []);
+                break;
+            case 'ticket':
+                await this.config.runCommand('template:ticket', []);
+                break;
+            case 'phase':
+                await this.config.runCommand('template:phase', []);
+                break;
+        }
+    }
+}

package/dist/commands/template/list.d.ts

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class TemplateList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        builtin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        custom: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    private printTicketTemplates;
+    private printPhaseTemplates;
+}

package/dist/commands/template/list.js

@@ -0,0 +1,157 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class TemplateList extends PMOCommand {
+    static description = 'List all templates (ticket and phase)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --type ticket',
+        '<%= config.bin %> <%= command.id %> --type phase',
+        '<%= config.bin %> <%= command.id %> --builtin',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        type: Flags.string({
+            char: 't',
+            description: 'Filter by template type',
+            options: ['ticket', 'phase'],
+        }),
+        builtin: Flags.boolean({
+            description: 'Show only built-in templates',
+            exclusive: ['custom'],
+        }),
+        custom: Flags.boolean({
+            description: 'Show only custom templates',
+            exclusive: ['builtin'],
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(TemplateList);
+        let builtinFilter;
+        if (flags.builtin)
+            builtinFilter = { isBuiltin: true };
+        if (flags.custom)
+            builtinFilter = { isBuiltin: false };
+        const typeFilter = flags.type;
+        const showTicket = !typeFilter || typeFilter === 'ticket';
+        const showPhase = !typeFilter || typeFilter === 'phase';
+        // Fetch all requested template types
+        const [ticketTemplates, phaseTemplates] = await Promise.all([
+            showTicket ? this.storage.listTicketTemplates(builtinFilter) : Promise.resolve([]),
+            showPhase ? this.storage.listPhaseTemplates(builtinFilter) : Promise.resolve([]),
+        ]);
+        if (flags.json) {
+            const result = {};
+            if (showTicket)
+                result.ticket = ticketTemplates;
+            if (showPhase)
+                result.phase = phaseTemplates;
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const totalCount = ticketTemplates.length + phaseTemplates.length;
+        if (totalCount === 0) {
+            this.log(styles.muted('\nNo templates found.'));
+            return;
+        }
+        this.log(`\n${styles.emphasis('Templates')}`);
+        this.log('═'.repeat(60));
+        // Ticket templates
+        if (showTicket && ticketTemplates.length > 0) {
+            this.log(`\n${styles.emphasis('Ticket Templates')} ${styles.muted(`(${ticketTemplates.length})`)}`);
+            this.log('─'.repeat(40));
+            this.printTicketTemplates(ticketTemplates, flags.builtin, flags.custom);
+        }
+        // Phase templates
+        if (showPhase && phaseTemplates.length > 0) {
+            this.log(`\n${styles.emphasis('Phase Templates')} ${styles.muted(`(${phaseTemplates.length})`)}`);
+            this.log('─'.repeat(40));
+            this.printPhaseTemplates(phaseTemplates, flags.builtin, flags.custom);
+        }
+        this.log('');
+        this.log(styles.muted('Commands:'));
+        if (showTicket)
+            this.log(styles.muted('  prlt template ticket apply <id>    - Create ticket from template'));
+        if (showPhase)
+            this.log(styles.muted('  prlt template phase apply <id>     - Apply phase template'));
+        this.log(styles.muted('  prlt workflow list                 - List available workflows'));
+        this.log('');
+    }
+    printTicketTemplates(templates, onlyBuiltin, onlyCustom) {
+        const builtinTemplates = templates.filter(t => t.isBuiltin);
+        const customTemplates = templates.filter(t => !t.isBuiltin);
+        const printOne = (template) => {
+            this.log(`  ${styles.emphasis(template.name)} ${styles.muted(`(${template.id})`)}`);
+            if (template.description) {
+                this.log(`    ${styles.muted(template.description)}`);
+            }
+            const details = [];
+            if (template.defaultPriority)
+                details.push(`Priority: ${template.defaultPriority}`);
+            if (template.defaultCategory)
+                details.push(`Category: ${template.defaultCategory}`);
+            if (template.suggestedSubtasks.length > 0)
+                details.push(`Subtasks: ${template.suggestedSubtasks.length}`);
+            if (details.length > 0) {
+                this.log(`    ${styles.muted(details.join(' | '))}`);
+            }
+        };
+        if (builtinTemplates.length > 0 && !onlyCustom) {
+            for (const template of builtinTemplates)
+                printOne(template);
+        }
+        if (customTemplates.length > 0 && !onlyBuiltin) {
+            if (builtinTemplates.length > 0 && !onlyCustom)
+                this.log('');
+            for (const template of customTemplates)
+                printOne(template);
+        }
+    }
+    printPhaseTemplates(templates, onlyBuiltin, onlyCustom) {
+        const builtinTemplates = templates.filter(t => t.isBuiltin);
+        const customTemplates = templates.filter(t => !t.isBuiltin);
+        const categoryEmoji = {
+            triage: '📬',
+            backlog: '📥',
+            unstarted: '📋',
+            started: '🚀',
+            completed: '✅',
+            canceled: '🚫',
+        };
+        const printOne = (template) => {
+            this.log(`  ${styles.emphasis(template.name)} ${styles.muted(`(${template.id})`)}`);
+            if (template.description) {
+                this.log(`    ${styles.muted(template.description)}`);
+            }
+            const phasesByCategory = new Map();
+            for (const phase of template.phases) {
+                const existing = phasesByCategory.get(phase.category) || [];
+                existing.push(phase.name);
+                phasesByCategory.set(phase.category, existing);
+            }
+            const phaseParts = [];
+            for (const [category, names] of phasesByCategory) {
+                phaseParts.push(`${categoryEmoji[category]} ${names.join(', ')}`);
+            }
+            this.log(`    ${styles.muted(phaseParts.join(' → '))}`);
+        };
+        if (builtinTemplates.length > 0 && !onlyCustom) {
+            for (const template of builtinTemplates)
+                printOne(template);
+        }
+        if (customTemplates.length > 0 && !onlyBuiltin) {
+            if (builtinTemplates.length > 0 && !onlyCustom)
+                this.log('');
+            for (const template of customTemplates)
+                printOne(template);
+        }
+    }
+}

package/dist/commands/template/phase/apply.d.ts

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

package/dist/commands/template/phase/apply.js

@@ -0,0 +1,41 @@
+import { Args, Command, Flags } from '@oclif/core';
+export default class TemplatePhaseApply extends Command {
+    static description = 'Apply a phase template to a project';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> agile',
+        '<%= config.bin %> <%= command.id %> waterfall --project my-project',
+        '<%= config.bin %> <%= command.id %> agile --force',
+    ];
+    static args = {
+        template: Args.string({
+            description: 'Phase template ID to apply',
+            required: true,
+        }),
+    };
+    static flags = {
+        project: Flags.string({
+            char: 'p',
+            description: 'Project ID or name',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt (will replace existing phases)',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TemplatePhaseApply);
+        const cmdArgs = [args.template];
+        if (flags.project)
+            cmdArgs.push('--project', flags.project);
+        if (flags.force)
+            cmdArgs.push('--force');
+        if (flags.json)
+            cmdArgs.push('--json');
+        await this.config.runCommand('phase:template:apply', cmdArgs);
+    }
+}

package/dist/commands/template/phase/create.d.ts

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

package/dist/commands/template/phase/create.js

@@ -0,0 +1,29 @@
+import { Args, Command, Flags } from '@oclif/core';
+export default class TemplatePhaseCreate extends Command {
+    static description = 'Create a new phase template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "My Phases"',
+        '<%= config.bin %> <%= command.id %> "Sprint Phases" --description "Agile sprint phases"',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Name for the new template',
+            required: false,
+        }),
+    };
+    static flags = {
+        description: Flags.string({
+            char: 'd',
+            description: 'Template description',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TemplatePhaseCreate);
+        const cmdArgs = [];
+        if (args.name)
+            cmdArgs.push(args.name);
+        if (flags.description)
+            cmdArgs.push('--description', flags.description);
+        await this.config.runCommand('phase:template:create', cmdArgs);
+    }
+}

package/dist/commands/template/phase/delete.d.ts

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

package/dist/commands/template/phase/delete.js

@@ -0,0 +1,34 @@
+import { Args, Command, Flags } from '@oclif/core';
+export default class TemplatePhaseDelete extends Command {
+    static description = 'Delete a phase template';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-template',
+        '<%= config.bin %> <%= command.id %> my-template --force',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Template ID to delete',
+            required: true,
+        }),
+    };
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TemplatePhaseDelete);
+        const cmdArgs = [args.id];
+        if (flags.force)
+            cmdArgs.push('--force');
+        if (flags.json)
+            cmdArgs.push('--json');
+        await this.config.runCommand('phase:template:delete', cmdArgs);
+    }
+}

package/dist/commands/template/phase/index.d.ts

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

package/dist/commands/template/phase/index.js

@@ -0,0 +1,62 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { styles } from '../../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class TemplatePhase extends Command {
+    static description = 'Manage phase templates (project lifecycle phases)';
+    static aliases = ['template:phases'];
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> list',
+        '<%= config.bin %> <%= command.id %> apply agile',
+        '<%= config.bin %> <%= command.id %> create "My Phases"',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TemplatePhase);
+        const jsonMode = shouldOutputJson(flags);
+        const menuChoices = [
+            { name: 'List phase templates', value: 'list' },
+            { name: 'Apply a phase template to project', value: 'apply' },
+            { name: 'Create a new phase template', value: 'create' },
+            { name: 'Update a phase template', value: 'update' },
+            { name: 'Delete a phase template', value: 'delete' },
+        ];
+        const message = 'What would you like to do?';
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, menuChoices), createMetadata('template phase', flags));
+            return;
+        }
+        this.log('');
+        this.log(styles.header('Phase Templates'));
+        this.log('');
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message,
+                choices: menuChoices.map(c => ({ name: c.name, value: c.value })),
+            }]);
+        switch (action) {
+            case 'list':
+                await this.config.runCommand('template:phase:list', []);
+                break;
+            case 'apply':
+                await this.config.runCommand('phase:template:apply', []);
+                break;
+            case 'create':
+                await this.config.runCommand('phase:template:create', []);
+                break;
+            case 'update':
+                await this.config.runCommand('phase:template:update', []);
+                break;
+            case 'delete':
+                await this.config.runCommand('phase:template:delete', []);
+                break;
+        }
+    }
+}

package/dist/commands/template/phase/list.d.ts

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

package/dist/commands/template/phase/list.js

@@ -0,0 +1,34 @@
+import { Command, Flags } from '@oclif/core';
+export default class TemplatePhaseList extends Command {
+    static description = 'List phase templates';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --builtin',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        builtin: Flags.boolean({
+            description: 'Show only built-in templates',
+            exclusive: ['custom'],
+        }),
+        custom: Flags.boolean({
+            description: 'Show only custom templates',
+            exclusive: ['builtin'],
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TemplatePhaseList);
+        const args = [];
+        if (flags.builtin)
+            args.push('--builtin');
+        if (flags.custom)
+            args.push('--custom');
+        if (flags.json)
+            args.push('--json');
+        await this.config.runCommand('phase:template:list', args);
+    }
+}