@sysprompthub/cli 1.1.0 → 2.0.0

package/dist/commands/custom-commands.test.js

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CustomAddCommand } from './custom-add.js';
+import { CustomRemoveCommand } from './custom-remove.js';
+vi.mock('../config-helpers.js', () => ({
+    loadProjectConfigEditor: vi.fn(),
+    validatePackName: vi.fn()
+}));
+vi.mock('is-valid-path', () => ({
+    default: vi.fn()
+}));
+describe('CustomAddCommand', () => {
+    let command;
+    let helpers;
+    let mockEditor;
+    let isValidPath;
+    let consoleErrorSpy;
+    let consoleLogSpy;
+    let processExitSpy;
+    beforeEach(async () => {
+        helpers = await import('../config-helpers.js');
+        const pathModule = await import('is-valid-path');
+        isValidPath = vi.mocked(pathModule.default);
+        vi.clearAllMocks();
+        mockEditor = {
+            packs: [],
+            addCustom: vi.fn()
+        };
+        vi.mocked(helpers.loadProjectConfigEditor).mockResolvedValue(mockEditor);
+        vi.mocked(helpers.validatePackName).mockReturnValue(true);
+        isValidPath.mockReturnValue(true);
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+        command = new CustomAddCommand();
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+        processExitSpy.mockRestore();
+    });
+    describe('run', () => {
+        it('should add custom pack', async () => {
+            await command.run('docs/prompt.md', 'owner/pack/latest', {});
+            expect(mockEditor.addCustom).toHaveBeenCalledWith({
+                path: 'docs/prompt.md',
+                pack: 'owner/pack/latest',
+                environment: undefined
+            });
+            expect(consoleLogSpy).toHaveBeenCalledWith('✓ Custom pack added: docs/prompt.md -> owner/pack/latest');
+        });
+        it('should exit with error on absolute path', async () => {
+            await command.run('/absolute/path.md', 'owner/pack/latest', {});
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Path must be relative to the current working directory');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+            expect(mockEditor.addCustom).not.toHaveBeenCalled();
+        });
+        it('should exit with error on invalid path', async () => {
+            isValidPath.mockReturnValue(false);
+            await command.run('invalid|path', 'owner/pack/latest', {});
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Invalid path format');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+            expect(mockEditor.addCustom).not.toHaveBeenCalled();
+        });
+        it('should exit with error on invalid pack name', async () => {
+            vi.mocked(helpers.validatePackName).mockReturnValue(false);
+            await command.run('docs/prompt.md', 'invalid-pack', {});
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Invalid pack name: invalid-pack');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+            expect(mockEditor.addCustom).not.toHaveBeenCalled();
+        });
+    });
+});
+describe('CustomRemoveCommand', () => {
+    let command;
+    let helpers;
+    let mockEditor;
+    let consoleErrorSpy;
+    let consoleLogSpy;
+    let consoleWarnSpy;
+    let processExitSpy;
+    beforeEach(async () => {
+        helpers = await import('../config-helpers.js');
+        vi.clearAllMocks();
+        mockEditor = {
+            packs: [],
+            removeCustom: vi.fn()
+        };
+        vi.mocked(helpers.loadProjectConfigEditor).mockResolvedValue(mockEditor);
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+        command = new CustomRemoveCommand();
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        processExitSpy.mockRestore();
+    });
+    describe('run', () => {
+        it('should remove custom pack', async () => {
+            vi.mocked(mockEditor.removeCustom).mockResolvedValue(true);
+            await command.run('docs/prompt.md');
+            expect(mockEditor.removeCustom).toHaveBeenCalledWith('docs/prompt.md');
+            expect(consoleLogSpy).toHaveBeenCalledWith('✓ Custom pack removed: docs/prompt.md');
+        });
+        it('should exit with error when pack not found', async () => {
+            vi.mocked(mockEditor.removeCustom).mockResolvedValue(false);
+            await command.run('docs/prompt.md');
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Error: Custom pack with path 'docs/prompt.md' not found");
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+        it('should warn when file deletion fails', async () => {
+            const error = new Error('File not found');
+            vi.mocked(mockEditor.removeCustom).mockResolvedValue(error);
+            await command.run('docs/prompt.md');
+            expect(consoleLogSpy).toHaveBeenCalledWith('✓ Custom pack removed: docs/prompt.md');
+            expect(consoleWarnSpy).toHaveBeenCalledWith('⚠ Warning: Could not delete prompt file: File not found');
+        });
+    });
+});

package/dist/commands/custom-remove.js

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+import { loadProjectConfigEditor } from '../config-helpers.js';
+export class CustomRemoveCommand {
+    async run(path) {
+        const editor = await loadProjectConfigEditor();
+        const result = await editor.removeCustom(path);
+        if (result === false) {
+            console.error(`Error: Custom pack with path '${path}' not found`);
+            process.exit(1);
+            return;
+        }
+        console.log(`✓ Custom pack removed: ${path}`);
+        if (result !== true) {
+            console.warn(`⚠ Warning: Could not delete prompt file: ${result.message}`);
+        }
+    }
+    create() {
+        const command = new Command('remove');
+        command
+            .description('Remove a custom path configuration')
+            .argument('<path>', 'Path to remove')
+            .action(async (path) => await this.run(path));
+        return command;
+    }
+}

package/dist/commands/custom.js

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import { CustomAddCommand } from './custom-add.js';
+import { CustomRemoveCommand } from './custom-remove.js';
+export function createCustomCommand() {
+    const custom = new Command('custom');
+    custom.description('Manage custom path configurations');
+    const addCmd = new CustomAddCommand();
+    const removeCmd = new CustomRemoveCommand();
+    custom.addCommand(addCmd.create());
+    custom.addCommand(removeCmd.create());
+    return custom;
+}

package/dist/commands/init.js

@@ -1,53 +1,23 @@
-import { checkbox, confirm, input, search } from '@inquirer/prompts';
+import { input, confirm } from '@inquirer/prompts';
 import { Command } from 'commander';
-import { API_KEY_LENGTH, AssistantManager, DefaultConfigManager, NodeFileSystem, SysPromptHubClient, UserConfigManager } from '@sysprompthub/sdk';
-import { isAbsolute } from 'path';
-import isValidPath from 'is-valid-path';
+import { API_KEY_LENGTH, NodeFileSystem, UserConfigManager } from '@sysprompthub/sdk';
 import open from 'open';
 import { BaseCommand } from "./base-command.js";
 export class InitCommand extends BaseCommand {
     fs = new NodeFileSystem();
-    workspaceConfigManager = new DefaultConfigManager();
     userConfigManager = new UserConfigManager();
-    async run({ environment }) {
-        console.log('Welcome to SysPromptHub! Let\'s configure your project.\n');
-        // Load existing configs
+    async run(_options) {
+        console.log('Welcome to SysPromptHub!\n');
+        // Load existing user config
         const existingUserConfig = await this.userConfigManager.load(this.fs);
-        const existingWorkspaceConfig = await this.workspaceConfigManager.load(this.fs) || {};
-        // Step 1: API Key (user-level)
+        // Prompt for API Key
         const apiKey = await this.promptForApiKey(existingUserConfig?.apiKey);
         await this.userConfigManager.save(this.fs, { apiKey });
-        // Environment
-        let workspaceConfig = { ...existingWorkspaceConfig };
-        if (environment)
-            workspaceConfig.environment = environment;
-        // Step 2: Pack Name (workspace-level)
-        const client = new SysPromptHubClient(apiKey, workspaceConfig.environment);
-        workspaceConfig.packName = await this.promptForPackName(client, workspaceConfig.packName);
-        // Step 3: Assistants (workspace-level)
-        workspaceConfig.assistants = await this.promptForAssistants(workspaceConfig.assistants);
-        // Step 4: Custom Path (workspace-level, if no assistants selected)
-        if (!workspaceConfig.assistants || workspaceConfig.assistants.length === 0) {
-            workspaceConfig.path = await this.promptForCustomPath(workspaceConfig.path);
-        }
-        // Save workspace configuration
-        await this.workspaceConfigManager.update(this.fs, workspaceConfig);
-        console.log('\n✓ User config saved to ~/.sysprompthub/config.json');
-        console.log('✓ Project config saved to .sysprompthub.json');
-        // Ask if user wants to sync now
-        const shouldSync = await confirm({
-            message: 'Would you like to sync your prompts now?',
-            default: true
-        });
-        if (shouldSync) {
-            console.log('\nSyncing prompts...');
-            const { SyncCommand } = await import('./sync.js');
-            const syncCommand = new SyncCommand();
-            await syncCommand.run({});
-        }
-        else {
-            console.log('Run "sysprompthub sync" to download your prompts.\n');
-        }
+        console.log('\n✓ API key saved to ~/.sysprompthub/config.json');
+        console.log('\nNext steps:');
+        console.log('  • Set primary pack: sysprompthub copilot set <pack>');
+        console.log('  • Add an agent: sysprompthub copilot agent add <name> <pack>');
+        console.log('  • Run sync: sysprompthub sync\n');
     }
     async promptForApiKey(existing) {
         const apiKey = await input({
@@ -79,132 +49,11 @@ export class InitCommand extends BaseCommand {
         }
         return apiKey;
     }
-    async promptForPackName(client, existing) {
-        if (existing) {
-            const keepExisting = await confirm({
-                message: `Keep existing pack "${existing}"?`,
-                default: true
-            });
-            if (keepExisting) {
-                return existing;
-            }
-        }
-        const packInfo = await this.searchAndSelectPack(client);
-        const version = await this.selectPackVersion(packInfo.name, packInfo.latestVersion);
-        return `${packInfo.name}/${version}`;
-    }
-    async searchAndSelectPack(client) {
-        const packResult = await search({
-            message: 'Type to search for packs...',
-            source: async (term) => {
-                if (!term || term.length < 3) {
-                    return [];
-                }
-                try {
-                    const results = await client.searchPacks(term);
-                    return results.map(result => ({
-                        name: result.name,
-                        value: JSON.stringify({ name: result.name, latestVersion: result.version }),
-                        description: `Current version: ${result.version}`
-                    }));
-                }
-                catch (error) {
-                    return [];
-                }
-            }
-        });
-        return JSON.parse(packResult);
-    }
-    async selectPackVersion(packName, latestVersion) {
-        const versionChoice = await search({
-            message: `Select version for ${packName}:`,
-            source: async () => {
-                const choices = [
-                    {
-                        name: 'latest',
-                        value: 'latest',
-                        description: 'Always use the latest version'
-                    },
-                    {
-                        name: `current (v${latestVersion})`,
-                        value: String(latestVersion),
-                        description: 'Use current version and manually update'
-                    }
-                ];
-                if (latestVersion > 1) {
-                    choices.push({
-                        name: '(other)',
-                        value: 'custom',
-                        description: 'Choose an older version'
-                    });
-                }
-                return choices;
-            }
-        });
-        if (versionChoice === 'custom') {
-            return await this.promptForCustomVersion(packName, latestVersion);
-        }
-        return versionChoice === 'latest' ? 'latest' : Number(versionChoice);
-    }
-    async promptForCustomVersion(packName, latestVersion) {
-        const customVersion = await input({
-            message: `Enter version number for ${packName} (1-${latestVersion}):`,
-            default: String(latestVersion),
-            validate: (value) => {
-                if (!value) {
-                    return 'Version is required';
-                }
-                if (!SysPromptHubClient.validateVersion(value, latestVersion)) {
-                    return `Version must be between 1 and ${latestVersion}`;
-                }
-                return true;
-            }
-        });
-        return Number(customVersion);
-    }
-    async promptForAssistants(existing) {
-        const am = new AssistantManager();
-        const choices = [];
-        am.forEach((assistant) => {
-            choices.push({
-                value: assistant.type,
-                name: assistant.type,
-                checked: existing?.includes(assistant.type) || assistant.type === 'copilot'
-            });
-        });
-        choices.push({
-            value: 'other',
-            name: 'Other (custom path)',
-            checked: existing?.includes('other')
-        });
-        const selected = await checkbox({
-            message: 'Select your coding assistants:',
-            choices
-        });
-        return selected.filter((s) => s !== 'other');
-    }
-    async promptForCustomPath(existing) {
-        const path = await input({
-            message: 'Enter the location where you want to save the prompt:',
-            default: existing,
-            validate: (value) => {
-                if (value.length === 0)
-                    return true;
-                if (isAbsolute(value))
-                    return 'Path must be relative to the current working directory';
-                if (!isValidPath(value))
-                    return 'Please enter a valid path';
-                return true;
-            }
-        });
-        return path.length > 0 ? path : undefined;
-    }
     create() {
         const command = new Command('init');
         command
-            .description('Initialize project system prompt configuration')
-            .addOption(InitCommand.envOption)
-            .action(async (env) => await this.run(env));
+            .description('Initialize API key configuration')
+            .action(async (options) => await this.run(options));
         return command;
     }
 }

package/dist/commands/init.test.js

@@ -2,8 +2,6 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { InitCommand } from './init.js';
 vi.mock('@inquirer/prompts', () => ({
     input: vi.fn(),
-    search: vi.fn(),
-    checkbox: vi.fn(),
     confirm: vi.fn()
 }));
 vi.mock('open', () => ({
@@ -16,20 +14,10 @@ vi.mock('@sysprompthub/sdk', () => {
         write: vi.fn(),
         createDir: vi.fn()
     };
-    const mockWorkspaceConfig = {
-        load: vi.fn(),
-        update: vi.fn()
-    };
     const mockUserConfig = {
         load: vi.fn(),
         save: vi.fn()
     };
-    const mockClient = {
-        searchPacks: vi.fn()
-    };
-    const mockAssistantManager = {
-        forEach: vi.fn()
-    };
     return {
         NodeFileSystem: class {
             exists = mockFs.exists;
@@ -37,27 +25,14 @@ vi.mock('@sysprompthub/sdk', () => {
             write = mockFs.write;
             createDir = mockFs.createDir;
         },
-        DefaultConfigManager: class {
-            load = mockWorkspaceConfig.load;
-            update = mockWorkspaceConfig.update;
-        },
         UserConfigManager: class {
             load = mockUserConfig.load;
             save = mockUserConfig.save;
         },
-        SysPromptHubClient: class {
-            searchPacks = mockClient.searchPacks;
-        },
-        AssistantManager: class {
-            forEach = mockAssistantManager.forEach;
-        },
         API_KEY_LENGTH: 40,
         __mocks: {
             mockFs,
-            mockWorkspaceConfig,
-            mockUserConfig,
-            mockClient,
-            mockAssistantManager
+            mockUserConfig
         }
     };
 });
@@ -74,8 +49,6 @@ describe('InitCommand', () => {
         mocks = sdk.__mocks;
         promptMocks = {
             input: vi.mocked(prompts.input),
-            search: vi.mocked(prompts.search),
-            checkbox: vi.mocked(prompts.checkbox),
             confirm: vi.mocked(prompts.confirm)
         };
         openMock = vi.mocked(open.default);
@@ -84,18 +57,9 @@ describe('InitCommand', () => {
         mocks.mockFs.read.mockReset();
         mocks.mockFs.write.mockReset();
         mocks.mockFs.createDir.mockReset();
-        mocks.mockWorkspaceConfig.load.mockReset().mockResolvedValue(null);
-        mocks.mockWorkspaceConfig.update.mockReset();
         mocks.mockUserConfig.load.mockReset().mockResolvedValue(null);
         mocks.mockUserConfig.save.mockReset();
-        mocks.mockClient.searchPacks.mockReset().mockResolvedValue([]);
-        mocks.mockAssistantManager.forEach.mockReset().mockImplementation((cb) => {
-            cb({ type: 'copilot' });
-            cb({ type: 'claude' });
-        });
         promptMocks.input.mockReset();
-        promptMocks.search.mockReset();
-        promptMocks.checkbox.mockReset();
         promptMocks.confirm.mockReset();
         openMock.mockReset();
         consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
@@ -108,62 +72,47 @@ describe('InitCommand', () => {
         it('should create a Command with correct configuration', () => {
             const command = initCommand.create();
             expect(command.name()).toBe('init');
-            expect(command.description()).toBe('Initialize project system prompt configuration');
+            expect(command.description()).toBe('Initialize API key configuration');
         });
     });
     describe('run', () => {
-        it('should prompt for API key, pack name, and assistants', async () => {
+        it('should prompt for API key and save it', async () => {
             promptMocks.input.mockResolvedValue('a'.repeat(40));
-            promptMocks.search
-                .mockResolvedValueOnce(JSON.stringify({ name: 'owner/pack', version: 5 })) // Pack search
-                .mockResolvedValueOnce('latest'); // Version selection
-            promptMocks.checkbox.mockResolvedValue(['copilot']);
             await initCommand.run({});
             expect(promptMocks.input).toHaveBeenCalled();
-            expect(promptMocks.search).toHaveBeenCalledTimes(2);
-            expect(promptMocks.checkbox).toHaveBeenCalled();
             expect(mocks.mockUserConfig.save).toHaveBeenCalledWith(expect.any(Object), { apiKey: 'a'.repeat(40) });
-            expect(mocks.mockWorkspaceConfig.update).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({
-                packName: 'owner/pack/latest',
-                assistants: ['copilot']
-            }));
+            expect(consoleLogSpy).toHaveBeenCalledWith('\n✓ API key saved to ~/.sysprompthub/config.json');
         });
         it('should keep existing API key if blank entered', async () => {
             mocks.mockUserConfig.load.mockResolvedValue({ apiKey: 'existing'.padEnd(40, 'x') });
-            promptMocks.input.mockResolvedValueOnce(''); // API key blank
-            promptMocks.search
-                .mockResolvedValueOnce(JSON.stringify({ name: 'owner/pack', version: 5 })) // Pack search
-                .mockResolvedValueOnce('latest'); // Version selection
-            promptMocks.checkbox.mockResolvedValue(['copilot']);
+            promptMocks.input.mockResolvedValueOnce('');
             await initCommand.run({});
             expect(mocks.mockUserConfig.save).toHaveBeenCalledWith(expect.any(Object), { apiKey: 'existing'.padEnd(40, 'x') });
         });
-        it('should prompt for custom path when no assistants selected', async () => {
-            promptMocks.input.mockResolvedValueOnce('a'.repeat(40)); // API key
-            promptMocks.input.mockResolvedValueOnce('custom/path'); // custom path
-            promptMocks.search
-                .mockResolvedValueOnce(JSON.stringify({ name: 'owner/pack', version: 5 })) // Pack search
-                .mockResolvedValueOnce('latest'); // Version selection
-            promptMocks.checkbox.mockResolvedValue([]);
+        it('should prompt to open browser when blank key entered with no existing key', async () => {
+            promptMocks.input
+                .mockResolvedValueOnce('')
+                .mockResolvedValueOnce('a'.repeat(40));
+            promptMocks.confirm.mockResolvedValue(true);
+            await initCommand.run({});
+            expect(promptMocks.confirm).toHaveBeenCalled();
+            expect(openMock).toHaveBeenCalledWith('https://app.sysprompthub.com/api-keys');
+            expect(mocks.mockUserConfig.save).toHaveBeenCalledWith(expect.any(Object), { apiKey: 'a'.repeat(40) });
+        });
+        it('should not open browser if user declines', async () => {
+            promptMocks.input
+                .mockResolvedValueOnce('')
+                .mockResolvedValueOnce('b'.repeat(40));
+            promptMocks.confirm.mockResolvedValue(false);
             await initCommand.run({});
-            expect(mocks.mockWorkspaceConfig.update).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({
-                path: 'custom/path'
-            }));
+            expect(promptMocks.confirm).toHaveBeenCalled();
+            expect(openMock).not.toHaveBeenCalled();
         });
-        it('should not set path when blank entered for custom path', async () => {
-            promptMocks.input.mockResolvedValueOnce('a'.repeat(40)); // API key
-            promptMocks.input.mockResolvedValueOnce(''); // blank custom path
-            promptMocks.search
-                .mockResolvedValueOnce(JSON.stringify({ name: 'owner/pack', version: 5 })) // Pack search
-                .mockResolvedValueOnce('latest'); // Version selection
-            promptMocks.checkbox.mockResolvedValue([]);
+        it('should display next steps after saving', async () => {
+            promptMocks.input.mockResolvedValue('a'.repeat(40));
             await initCommand.run({});
-            expect(mocks.mockWorkspaceConfig.update).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({
-                packName: 'owner/pack/latest',
-                assistants: []
-            }));
-            const updateCall = mocks.mockWorkspaceConfig.update.mock.calls[0][1];
-            expect(updateCall.path).toBeUndefined();
+            expect(consoleLogSpy).toHaveBeenCalledWith('\nNext steps:');
+            expect(consoleLogSpy).toHaveBeenCalledWith('  • Set primary pack: sysprompthub copilot set <pack>');
         });
     });
 });

package/dist/commands/show.js

@@ -0,0 +1,99 @@
+import { Command } from 'commander';
+import { loadProjectConfigEditor } from '../config-helpers.js';
+import { assistantManager } from '@sysprompthub/sdk';
+export class ShowCommand {
+    static INDENT = "\n    ";
+    async run() {
+        const editor = await loadProjectConfigEditor();
+        if (!editor.packs || editor.packs.length === 0) {
+            console.log('No packs configured for this project.');
+            console.log('\nGet started:');
+            console.log('  • sysprompthub copilot set <pack>');
+            console.log('  • sysprompthub claude set <pack>');
+            console.log('  • sysprompthub custom add <path> <pack>');
+            return;
+        }
+        // Separate non-custom and custom packs
+        const assistantPacks = editor.packs.filter(p => p.type !== 'custom');
+        const customPacks = editor.packs.filter(p => p.type === 'custom');
+        // Sort assistant packs by type then agent name
+        const sortedAssistantPacks = assistantPacks.sort((a, b) => {
+            if (a.type !== b.type) {
+                return a.type.localeCompare(b.type);
+            }
+            const aName = a.agent?.name || '';
+            const bName = b.agent?.name || '';
+            return aName.localeCompare(bName);
+        });
+        // Sort custom packs by path
+        const sortedCustomPacks = customPacks.sort((a, b) => {
+            return (a.path || '').localeCompare(b.path || '');
+        });
+        // Display assistant packs
+        for (const pack of sortedAssistantPacks) {
+            this.displayAssistantPack(pack);
+        }
+        // Display custom packs
+        for (const pack of sortedCustomPacks) {
+            this.displayCustomPack(pack);
+        }
+    }
+    displayAssistantPack(pack) {
+        if (pack.type === 'custom')
+            return;
+        const { agentName, prompt } = this.packConfigInfo(pack);
+        // Extract frontmatter (all properties except 'name')
+        const frontmatter = {};
+        if (pack.agent) {
+            for (const [key, value] of Object.entries(pack.agent)) {
+                if (key !== 'name') {
+                    frontmatter[key] = value;
+                }
+            }
+        }
+        let details = {
+            pack: pack.pack,
+            prompt,
+            ...frontmatter
+        };
+        if (pack.environment)
+            details.environment = pack.environment;
+        let name = pack.agent ? `${pack.type} ${agentName} "${pack.agent.name}"` : pack.type;
+        console.log([name, ...this.formatDetails(details)].join(ShowCommand.INDENT) + "\n");
+    }
+    packConfigInfo(pack) {
+        const assistantClass = assistantManager.getAssistantClass(pack.type);
+        return {
+            agentName: assistantClass.agents === false ? undefined : assistantClass.agents.name,
+            prompt: new assistantClass().promptPath(pack)
+        };
+    }
+    formatDetails(details) {
+        const prefixLength = Math.max(...Object.keys(details).map(k => k.length)) + 2;
+        return Object.entries(details).map(([key, value]) => {
+            const prefix = `${key}:`.padEnd(prefixLength);
+            return `${prefix}${value}`;
+        });
+    }
+    displayCustomPack(pack) {
+        if (pack.type !== 'custom')
+            return;
+        console.log(`custom "${pack.path}": ${pack.pack}${this.formatEnv(pack.environment)}`);
+    }
+    formatEnv(env) {
+        return env ? ` [${env}]` : '';
+    }
+    formatFrontmatter(agent) {
+        const entries = Object.entries(agent)
+            .filter(([key]) => key !== 'name')
+            .map(([key, value]) => `${key}=${value}`);
+        return entries.length > 0 ? ` (${entries.join(', ')})` : '';
+    }
+    create() {
+        const command = new Command('show');
+        command
+            .description('Show all configured packs for this project')
+            .action(async () => await this.run());
+        return command;
+    }
+}