@proletariat/cli 0.2.0 → 0.3.1

package/dist/commands/agent/themes/add-names.js

@@ -0,0 +1,67 @@
+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 {
+    static description = 'Add names to a theme';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> greek-gods zeus athena poseidon',
+        '<%= config.bin %> <%= command.id %> my-theme agent-a agent-b',
+    ];
+    static args = {
+        theme: Args.string({
+            description: 'Theme ID to add names to',
+            required: true,
+        }),
+    };
+    static strict = false; // Allow multiple name arguments
+    async run() {
+        const { args, argv } = await this.parse(ThemesAddNames);
+        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.`);
+            }
+            // Get names from remaining arguments (skip the theme arg)
+            const rawNames = argv.slice(1);
+            if (rawNames.length === 0) {
+                this.error('Please provide at least one name to add.');
+            }
+            // Normalize and validate names
+            const validNames = [];
+            const normalized = [];
+            for (const name of rawNames) {
+                const normalizedName = normalizeAgentName(name);
+                if (normalizedName && isValidAgentName(normalizedName)) {
+                    validNames.push(normalizedName);
+                    if (normalizedName !== name) {
+                        normalized.push({ original: name, normalized: normalizedName });
+                    }
+                }
+            }
+            if (validNames.length === 0) {
+                this.error('No valid names to add after normalization.');
+            }
+            // Show normalizations
+            if (normalized.length > 0) {
+                this.log(chalk.blue('Normalized names:'));
+                for (const { original, normalized: norm } of normalized) {
+                    this.log(chalk.dim(`   ${original} → ${norm}`));
+                }
+            }
+            // Add names to theme
+            addThemeNames(workspaceInfo.path, theme.id, validNames);
+            // Get updated count
+            const allNames = getThemeNames(workspaceInfo.path, theme.id);
+            this.log(chalk.green(`\n Added ${validNames.length} name(s) to ${theme.display_name}:`));
+            this.log(chalk.gray(`   ${validNames.join(', ')}`));
+            this.log(chalk.gray(`\n   Theme now has ${allNames.length} names total.`));
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/commands/agent/themes/create.d.ts

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

package/dist/commands/agent/themes/create.js

@@ -0,0 +1,66 @@
+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 {
+    static description = 'Create a custom agent theme';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> greek-gods',
+        '<%= config.bin %> <%= command.id %> greek-gods --description "Mount Olympus crew"',
+        '<%= config.bin %> <%= command.id %> greek-gods --display-name "Greek Gods"',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Theme name (used as ID, lowercase with hyphens)',
+            required: true,
+        }),
+    };
+    static flags = {
+        description: Flags.string({
+            char: 'd',
+            description: 'Theme description',
+        }),
+        'display-name': Flags.string({
+            description: 'Display name (defaults to formatted name)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ThemesCreate);
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            // Validate theme name format
+            const name = args.name.toLowerCase().replace(/\s+/g, '-');
+            if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+                this.error('Theme name must be lowercase alphanumeric with optional hyphens.');
+            }
+            // Check if theme already exists
+            const existing = getTheme(workspaceInfo.path, name);
+            if (existing) {
+                this.error(`Theme "${name}" already exists.`);
+            }
+            // Create display name from name if not provided
+            const displayName = flags['display-name'] || name
+                .split('-')
+                .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+                .join(' ');
+            // Create the theme
+            const theme = createTheme(workspaceInfo.path, {
+                id: name,
+                name: name,
+                displayName: displayName,
+                description: flags.description,
+                builtin: false,
+            });
+            this.log(chalk.green(`\n Created theme: ${theme.display_name}`));
+            this.log(chalk.gray(`   ID: ${theme.id}`));
+            if (theme.description) {
+                this.log(chalk.gray(`   ${theme.description}`));
+            }
+            this.log('');
+            this.log(chalk.blue('Add names with: prlt agent themes add-names ' + name + ' <names...>'));
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/commands/agent/themes/index.d.ts

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

package/dist/commands/agent/themes/index.js

@@ -0,0 +1,194 @@
+import { Command, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { getWorkspaceInfo } from '../../../lib/agents/commands.js';
+import { ensureBuiltinThemes } from '../../../lib/themes.js';
+import { getThemes, getThemeNames } from '../../../lib/database/index.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class Themes extends Command {
+    static description = 'Manage agent naming themes';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> list',
+        '<%= config.bin %> <%= command.id %> create greek-gods',
+        '<%= config.bin %> <%= command.id %> add-names greek-gods zeus athena',
+    ];
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Themes);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        // Each choice includes the full command for AI agents to execute
+        const menuChoices = [
+            { id: 'list', name: 'List themes', command: 'prlt agent themes list --format json' },
+            { id: 'create', name: 'Create a new theme', command: 'prlt agent themes create --json' },
+            { id: 'add-names', name: 'Add names to a theme', command: 'prlt agent themes add-names --json' },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'What would you like to do?';
+        // In JSON mode, output menu prompt with commands for AI agents
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, menuChoices.map(c => ({
+                name: c.name,
+                value: c.id,
+                command: c.command,
+            }))), createMetadata('agent themes', flags));
+            return;
+        }
+        this.log(chalk.bold('\nAgent Themes'));
+        this.log(chalk.dim('Optional themed name pools for your agents.\n'));
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message,
+                choices: [
+                    ...menuChoices.slice(0, 3).map(c => ({ name: c.name, value: c.id })),
+                    new inquirer.Separator(),
+                    { name: menuChoices[3].name, value: menuChoices[3].id }
+                ]
+            }]);
+        if (action === 'cancel') {
+            this.log(chalk.dim('Cancelled.'));
+            return;
+        }
+        try {
+            switch (action) {
+                case 'list': {
+                    const { default: ListCommand } = await import('./list.js');
+                    const cmd = new ListCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
+                case 'create': {
+                    // Prompt for theme name interactively
+                    const { themeName } = await inquirer.prompt([{
+                            type: 'input',
+                            name: 'themeName',
+                            message: 'Theme name:',
+                            validate: (input) => {
+                                if (!input.trim())
+                                    return 'Theme name is required';
+                                return true;
+                            }
+                        }]);
+                    // Normalize: lowercase, spaces to dashes
+                    const normalized = themeName.trim().toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+                    if (themeName.trim() !== normalized) {
+                        this.log(chalk.blue(`Normalized: ${themeName.trim()} → ${normalized}`));
+                    }
+                    const { default: CreateCommand } = await import('./create.js');
+                    const cmd = new CreateCommand([normalized], this.config);
+                    await cmd.run();
+                    // Prompt to add names immediately
+                    const { addNamesNow } = await inquirer.prompt([{
+                            type: 'list',
+                            name: 'addNamesNow',
+                            message: 'Add names to this theme now?',
+                            choices: [
+                                { name: 'Yes', value: true },
+                                { name: 'No', value: false },
+                            ],
+                        }]);
+                    if (addNamesNow) {
+                        const { names } = await inquirer.prompt([{
+                                type: 'input',
+                                name: 'names',
+                                message: 'Enter names (space-separated):',
+                                validate: (input) => input.trim() ? true : 'At least one name is required'
+                            }]);
+                        const args = [normalized, ...names.trim().split(/\s+/)];
+                        const { default: AddNamesCommand } = await import('./add-names.js');
+                        const addCmd = new AddNamesCommand(args, this.config);
+                        await addCmd.run();
+                    }
+                    break;
+                }
+                case 'add-names': {
+                    // Get available themes and show a selection list
+                    const workspaceInfo = getWorkspaceInfo();
+                    ensureBuiltinThemes(workspaceInfo.path);
+                    const themes = getThemes(workspaceInfo.path);
+                    if (themes.length === 0) {
+                        this.log(chalk.yellow('No themes found. Create one first.'));
+                        return;
+                    }
+                    // Build choices with theme info
+                    const themeChoices = themes.map(t => {
+                        const names = getThemeNames(workspaceInfo.path, t.id);
+                        const available = names.filter(n => !n.used).length;
+                        const builtinTag = t.builtin ? chalk.dim(' [built-in]') : '';
+                        return {
+                            name: `${t.display_name}${builtinTag} ${chalk.dim(`(${available} names available)`)}`,
+                            value: t.id
+                        };
+                    });
+                    // Add option to create new theme
+                    themeChoices.push(new inquirer.Separator());
+                    themeChoices.push({ name: chalk.green('+ Create new theme'), value: '__create_new__' });
+                    const { selectedTheme } = await inquirer.prompt([{
+                            type: 'list',
+                            name: 'selectedTheme',
+                            message: 'Select theme to add names to:',
+                            choices: themeChoices
+                        }]);
+                    // If they want to create a new theme first
+                    if (selectedTheme === '__create_new__') {
+                        const { themeName } = await inquirer.prompt([{
+                                type: 'input',
+                                name: 'themeName',
+                                message: 'Theme name:',
+                                validate: (input) => {
+                                    if (!input.trim())
+                                        return 'Theme name is required';
+                                    return true;
+                                }
+                            }]);
+                        // Normalize: lowercase, spaces to dashes
+                        const normalizedTheme = themeName.trim().toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+                        if (themeName.trim() !== normalizedTheme) {
+                            this.log(chalk.blue(`Normalized: ${themeName.trim()} → ${normalizedTheme}`));
+                        }
+                        const { default: CreateCommand } = await import('./create.js');
+                        const createCmd = new CreateCommand([normalizedTheme], this.config);
+                        await createCmd.run();
+                        // Now prompt for names to add to the new theme
+                        const { names } = await inquirer.prompt([{
+                                type: 'input',
+                                name: 'names',
+                                message: 'Names to add (space-separated):',
+                                validate: (input) => input.trim() ? true : 'At least one name is required'
+                            }]);
+                        const args = [normalizedTheme, ...names.trim().split(/\s+/)];
+                        const { default: AddNamesCommand } = await import('./add-names.js');
+                        const cmd = new AddNamesCommand(args, this.config);
+                        await cmd.run();
+                    }
+                    else {
+                        // Prompt for names to add
+                        const { names } = await inquirer.prompt([{
+                                type: 'input',
+                                name: 'names',
+                                message: 'Names to add (space-separated):',
+                                validate: (input) => input.trim() ? true : 'At least one name is required'
+                            }]);
+                        const args = [selectedTheme, ...names.trim().split(/\s+/)];
+                        const { default: AddNamesCommand } = await import('./add-names.js');
+                        const cmd = new AddNamesCommand(args, this.config);
+                        await cmd.run();
+                    }
+                    break;
+                }
+                default:
+                    this.error(`Unknown action: ${action}`);
+            }
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/commands/agent/themes/list.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class ThemesList extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/agent/themes/list.js

@@ -0,0 +1,41 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import { getWorkspaceInfo } from '../../../lib/agents/commands.js';
+import { ensureBuiltinThemes } from '../../../lib/themes.js';
+import { getThemes, getThemeNames } from '../../../lib/database/index.js';
+export default class ThemesList extends Command {
+    static description = 'List available agent themes';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            // Ensure built-in themes are seeded
+            ensureBuiltinThemes(workspaceInfo.path);
+            const themes = getThemes(workspaceInfo.path);
+            if (themes.length === 0) {
+                this.log(chalk.yellow('No themes found.'));
+                return;
+            }
+            this.log(chalk.bold('\nAgent Themes\n'));
+            for (const theme of themes) {
+                const names = getThemeNames(workspaceInfo.path, theme.id);
+                const available = names.filter(n => !n.used).length;
+                const used = names.filter(n => n.used).length;
+                const builtinTag = theme.builtin ? chalk.gray(' [built-in]') : '';
+                this.log(`  ${chalk.cyan(theme.display_name)}${builtinTag}`);
+                this.log(chalk.gray(`    ID: ${theme.id}`));
+                if (theme.description) {
+                    this.log(chalk.gray(`    ${theme.description}`));
+                }
+                this.log(chalk.gray(`    Names: ${chalk.green(available + ' available')}, ${chalk.yellow(used + ' in use')}`));
+                this.log('');
+            }
+            this.log(chalk.blue('Use: prlt agent add --theme <theme-id>'));
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/commands/agent/themes/set.d.ts

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

package/dist/commands/agent/themes/set.js

@@ -0,0 +1,77 @@
+import { Command, Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { getWorkspaceInfo } from '../../../lib/agents/commands.js';
+import { ensureBuiltinThemes } from '../../../lib/themes.js';
+import { getThemes, getAvailableThemeNames, setActiveTheme, getActiveTheme } from '../../../lib/database/index.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../../lib/prompt-json.js';
+export default class ThemesSet extends Command {
+    static description = 'Set the active theme for this workspace';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> billionaires',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        theme: Args.string({
+            description: 'Theme ID to set as active',
+            required: false,
+        }),
+    };
+    static flags = {
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ThemesSet);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            ensureBuiltinThemes(workspaceInfo.path);
+            let themeId = args.theme;
+            if (!themeId) {
+                // Interactive selection
+                const themes = getThemes(workspaceInfo.path);
+                const currentTheme = getActiveTheme(workspaceInfo.path);
+                // In JSON mode, output theme selection prompt
+                if (jsonMode) {
+                    const themeChoices = themes.map(t => {
+                        const availableCount = getAvailableThemeNames(workspaceInfo.path, t.id).length;
+                        const isCurrent = currentTheme?.id === t.id;
+                        return {
+                            name: `${t.display_name} (${availableCount} available)${isCurrent ? ' ✓ current' : ''}`,
+                            value: t.id
+                        };
+                    });
+                    outputPromptAsJson(buildPromptConfig('list', 'theme', 'Select theme for this workspace:', themeChoices), createMetadata('agent themes set', flags));
+                    return;
+                }
+                const choices = themes.map(t => {
+                    const availableCount = getAvailableThemeNames(workspaceInfo.path, t.id).length;
+                    const isCurrent = currentTheme?.id === t.id;
+                    return {
+                        name: `${t.display_name} ${chalk.dim(`(${availableCount} available)`)}${isCurrent ? chalk.green(' ✓ current') : ''}`,
+                        value: t.id
+                    };
+                });
+                const { selected } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selected',
+                        message: 'Select theme for this workspace:',
+                        choices
+                    }]);
+                themeId = selected;
+            }
+            setActiveTheme(workspaceInfo.path, themeId);
+            const themes = getThemes(workspaceInfo.path);
+            const theme = themes.find(t => t.id === themeId);
+            this.log(chalk.green(`\n✓ Active theme set to: ${theme?.display_name || themeId}`));
+            this.log(chalk.dim('  New agents will be selected from this theme.'));
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/commands/agent/visit.d.ts

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

package/dist/commands/agent/visit.js

@@ -0,0 +1,88 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import inquirer from 'inquirer';
+import { colors } from '../../lib/colors.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class Visit extends PMOCommand {
+    static description = 'Navigate to agent directory';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> camry',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Agent name to visit',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(Visit);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('agent visit', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get workspace information
+        const workspaceInfo = getWorkspaceInfo();
+        if (workspaceInfo.agents.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_AGENTS', 'No agents found. Add agents with "prlt agent add"', createMetadata('agent visit', flags));
+                return;
+            }
+            this.log(colors.warning('No agents found. Add agents with "prlt agent add"'));
+            return;
+        }
+        let agentName = args.name;
+        // Interactive mode if no agent specified
+        if (!agentName) {
+            // In JSON mode, output agent selection prompt
+            if (jsonMode) {
+                const agentChoices = workspaceInfo.agents.map((agent) => ({ name: agent.name, value: agent.name }));
+                outputPromptAsJson(buildPromptConfig('list', 'name', 'Select agent to visit:', agentChoices), createMetadata('agent visit', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select agent to visit:',
+                    choices: workspaceInfo.agents.map(agent => ({
+                        name: agent.name,
+                        value: agent.name
+                    }))
+                }
+            ]);
+            agentName = selected;
+        }
+        // Validate agent exists
+        const agent = workspaceInfo.agents.find(a => a.name === agentName);
+        if (!agent) {
+            return handleError('AGENT_NOT_FOUND', `Agent "${agentName}" not found. Available agents: ${workspaceInfo.agents.map(a => a.name).join(', ')}`);
+        }
+        // Calculate path to agent directory
+        const agentDir = path.join(workspaceInfo.agentsPath, agentName);
+        const relativePath = path.relative(process.cwd(), agentDir);
+        // Display navigation command
+        this.log(colors.primary(`🤖 Visiting agent: ${agentName}`));
+        this.log(colors.command(`cd ${relativePath}`));
+        this.log('');
+        this.log(colors.textSecondary('Note: Due to shell limitations, you need to run this command manually.'));
+    }
+}

package/dist/commands/autocomplete/setup.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class AutocompleteSetup extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        install: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        shell: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private detectShell;
+    private getShellConfig;
+    private showInstructions;
+    private installAutocomplete;
+}