@sysprompthub/cli 1.1.1 → 2.0.0

package/README.md

@@ -1,8 +1,12 @@
 # @sysprompthub/cli
 
-Command-line interface for syncing system prompts from SysPromptHub to your projects.
+Uplevel your AI development assistant with guardrails from [SysPromptHub](https://sysprompthub.com).
 
-For programmatic usage, see [@sysprompthub/sdk](https://www.npmjs.com/package/@sysprompthub/sdk).
+Now with support for **Claude Skills** and **GitHub Copilot Agents**!
+
+> 🌐 For VS Code integration, see the [SysPromptHub Extension](https://marketplace.visualstudio.com/items?itemName=sysprompthub.sysprompthub)
+>
+> ⏳ Jetbrains IDE integration coming soon!
 
 ## Installation
 
@@ -10,40 +14,109 @@ For programmatic usage, see [@sysprompthub/sdk](https://www.npmjs.com/package/@s
 npm install -g @sysprompthub/cli
 ```
 
-## CLI Usage
+## Features
+
+- 🎯 **Multiple assistants** - Configure GitHub Copilot, Claude Desktop, and custom paths
+- 🤖 **Agent/Skill support** - Manage specialized agents for different tasks
+- 🔄 **Easy syncing** - Download and install prompts with one command
+- 📝 **Interactive setup** - Guided configuration with search and selection
+
+## Commands
 
-### Init Command
+### Initial setup
 
-Initialize SysPromptHub configuration for your project:
+Initialize or update your development environment.
 
 ```bash
 sysprompthub init
 ```
 
-This interactive command will:
-1. Prompt for your API key (find yours at https://app.sysprompthub.com/api-keys)
-2. Let you search and select a prompt pack
-3. Let you select your AI assistants (Copilot, Claude, or custom path)
-4. Save workspace configuration to `.sysprompthub.json`
+### Configure prompt packs for your assistant
 
-### Sync Command
+```shell
+sysprompthub copilot set sysprompthub/python/latest
+sysprompthub claude skill add web-dev sysprompthub/react-tailwind/latest description="Skill to write frontend code" context=fork
+```
 
-Sync prompts from your configured pack:
 
-```bash
+### Sync your prompt packs
+
+Download and install configured prompts.
+
+```shell
 sysprompthub sync
 ```
 
-## Workflow
+### List your configured packs
+
+Display all configured packs for your project.
+
+```bash
+sysprompthub show
+```
+
+
+## Assistant Commands
+
+### GitHub Copilot
+
+See `sysprompthub copilot --help` for more details.
+
+**Example:**
+```bash
+# Set main prompt
+sysprompthub copilot set owner/general/latest
+
+# Add specialized agents
+sysprompthub copilot agent add python owner/python-expert/v1.0.0
+sysprompthub copilot agent add typescript owner/ts-expert/latest description="My typescript agent"
+```
+
+### Claude Desktop
+
+See `sysprompthub claude --help` for more details.
+
+**Example:**
+```bash
+# Set main prompt
+sysprompthub claude set owner/general/latest
+
+# Add skills
+sysprompthub claude skill add angular owner/angular-expert/v2.0.0 description="Skill to write angular code"
+sysprompthub claude skill remove angular
+```
+
+### Custom Paths
+
+See `sysprompthub custom --help` for more details.
 
-1. **First time setup**: Run `sysprompthub init` to configure your API key and project
-2. **Sync prompts**: Run `sysprompthub sync` to download and install prompts
-3. **Update**: Run `sysprompthub init` again to change configuration
+**Example:**
+```bash
+sysprompthub custom add docs/ai-prompt.md someone/markdown/latest
+sysprompthub custom remove docs/ai-prompt.md
+```
+
+## Configuration
+
+Project configuration is stored in the `.sysprompthub.json` file in the root of your project.
+
+User configuration is stored in the `~/.sysprompthub` directory.
+
+## Programmatic Usage
+
+For Node.js/TypeScript integration, use [@sysprompthub/sdk](https://www.npmjs.com/package/@sysprompthub/sdk).
+
+## Getting Help
+
+```bash
+# Show all commands
+sysprompthub --help
+```
 
 ## Contributing
 
-See [CONTRIBUTING.md](./CONTRIBUTING.md) for development instructions.
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for development setup and guidelines.
 
 ## License
 
-See [LICENSE](./LICENSE)
+ISC

package/dist/commands/agent-add.js

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import { loadProjectConfigEditor, validatePackName, validateAgentName, parseFrontmatterArg } from '../config-helpers.js';
+import { BaseCommand } from "./base-command.js";
+export class AgentAddCommand extends BaseCommand {
+    assistant;
+    agentTerm;
+    constructor(assistant, agentTerm) {
+        super();
+        this.assistant = assistant;
+        this.agentTerm = agentTerm;
+    }
+    async run({ name, pack, environment, frontmatter }) {
+        // Validate agent name
+        if (!validateAgentName(name)) {
+            console.error(`Error: Invalid ${this.agentTerm} name: ${name}`);
+            console.error('Name must contain only lowercase letters, numbers, hyphens, and underscores');
+            process.exit(1);
+            return;
+        }
+        // Validate pack format
+        if (!validatePackName(pack)) {
+            console.error(`Error: Invalid pack name: ${pack}`);
+            console.error('Expected format: owner/pack/version');
+            process.exit(1);
+            return;
+        }
+        // Load project config editor
+        const editor = await loadProjectConfigEditor();
+        // Add agent using editor
+        await editor.addAgent({
+            assistant: this.assistant,
+            name,
+            pack,
+            frontMatter: frontmatter,
+            environment
+        });
+        console.log(`✓ ${this.assistant} ${this.agentTerm} '${name}' added with pack ${pack}`);
+    }
+    create() {
+        const command = new Command('add');
+        command
+            .description(`Add a ${this.assistant} ${this.agentTerm}`)
+            .argument('<name>', `${this.agentTerm} name (lowercase, alphanumeric, hyphens, underscores)`)
+            .argument('<pack>', 'Pack name (owner/pack/version)')
+            .argument('[frontmatter...]', 'Frontmatter key-value pairs (e.g. description="My agent")', parseFrontmatterArg)
+            .addOption(AgentAddCommand.envOption)
+            .action(async (name, pack, frontmatter, options) => await this.run({ name, pack, frontmatter, environment: options.environment }));
+        return command;
+    }
+}

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

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { AgentAddCommand } from './agent-add.js';
+import { AgentRemoveCommand } from './agent-remove.js';
+vi.mock('../config-helpers.js', () => ({
+    loadProjectConfigEditor: vi.fn(),
+    validatePackName: vi.fn(),
+    validateAgentName: vi.fn(),
+    parseFrontmatterArg: vi.fn()
+}));
+describe('AgentAddCommand', () => {
+    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: [],
+            addAgent: vi.fn()
+        };
+        vi.mocked(helpers.loadProjectConfigEditor).mockResolvedValue(mockEditor);
+        vi.mocked(helpers.validatePackName).mockReturnValue(true);
+        vi.mocked(helpers.validateAgentName).mockReturnValue(true);
+        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 AgentAddCommand('copilot', 'agent');
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        processExitSpy.mockRestore();
+    });
+    describe('run', () => {
+        it('should add new agent', async () => {
+            await command.run({ name: 'python', pack: 'owner/pack/latest', frontmatter: {}, environment: undefined });
+            expect(helpers.validateAgentName).toHaveBeenCalledWith('python');
+            expect(helpers.validatePackName).toHaveBeenCalledWith('owner/pack/latest');
+            expect(mockEditor.addAgent).toHaveBeenCalledWith({
+                assistant: 'copilot',
+                name: 'python',
+                pack: 'owner/pack/latest',
+                frontMatter: {},
+                environment: undefined
+            });
+            expect(consoleLogSpy).toHaveBeenCalledWith("✓ copilot agent 'python' added with pack owner/pack/latest");
+        });
+        it('should exit with error on invalid agent name', async () => {
+            vi.mocked(helpers.validateAgentName).mockReturnValue(false);
+            await command.run({ name: 'Invalid-Name', pack: 'owner/pack/latest', frontmatter: {}, environment: undefined });
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Invalid agent name: Invalid-Name');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+            expect(mockEditor.addAgent).not.toHaveBeenCalled();
+        });
+        it('should exit with error on invalid pack name', async () => {
+            vi.mocked(helpers.validatePackName).mockReturnValue(false);
+            await command.run({ name: 'python', pack: 'invalid-pack', frontmatter: {}, environment: undefined });
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Invalid pack name: invalid-pack');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+            expect(mockEditor.addAgent).not.toHaveBeenCalled();
+        });
+    });
+});
+describe('AgentRemoveCommand', () => {
+    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: [],
+            removeAgent: 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 AgentRemoveCommand('copilot', 'agent');
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        processExitSpy.mockRestore();
+    });
+    describe('run', () => {
+        it('should remove agent', async () => {
+            vi.mocked(mockEditor.removeAgent).mockResolvedValue(true);
+            await command.run('python');
+            expect(mockEditor.removeAgent).toHaveBeenCalledWith('copilot', 'python');
+            expect(consoleLogSpy).toHaveBeenCalledWith("✓ copilot agent 'python' removed");
+        });
+        it('should exit with error when agent not found', async () => {
+            vi.mocked(mockEditor.removeAgent).mockResolvedValue(false);
+            await command.run('python');
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Error: copilot agent 'python' not found");
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+        it('should warn when file deletion fails', async () => {
+            const error = new Error('File not found');
+            vi.mocked(mockEditor.removeAgent).mockResolvedValue(error);
+            await command.run('python');
+            expect(consoleLogSpy).toHaveBeenCalledWith("✓ copilot agent 'python' removed");
+            expect(consoleWarnSpy).toHaveBeenCalledWith('⚠ Warning: Could not delete prompt file: File not found');
+        });
+    });
+});

package/dist/commands/agent-remove.js

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import { loadProjectConfigEditor } from '../config-helpers.js';
+export class AgentRemoveCommand {
+    assistant;
+    agentTerm;
+    constructor(assistant, agentTerm) {
+        this.assistant = assistant;
+        this.agentTerm = agentTerm;
+    }
+    async run(name) {
+        const editor = await loadProjectConfigEditor();
+        const result = await editor.removeAgent(this.assistant, name);
+        if (result === false) {
+            console.error(`Error: ${this.assistant} ${this.agentTerm} '${name}' not found`);
+            process.exit(1);
+            return;
+        }
+        console.log(`✓ ${this.assistant} ${this.agentTerm} '${name}' removed`);
+        if (result !== true) {
+            console.warn(`⚠ Warning: Could not delete prompt file: ${result.message}`);
+        }
+    }
+    create() {
+        const command = new Command('remove');
+        command
+            .description(`Remove a ${this.assistant} ${this.agentTerm}`)
+            .argument('<name>', `${this.agentTerm} name`)
+            .action(async (name) => await this.run(name));
+        return command;
+    }
+}

package/dist/commands/assistant-clear.js

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import { loadProjectConfigEditor } from '../config-helpers.js';
+export class AssistantClearCommand {
+    assistant;
+    constructor(assistant) {
+        this.assistant = assistant;
+    }
+    async run(options) {
+        const editor = await loadProjectConfigEditor();
+        if (!editor.packs || editor.packs.length === 0) {
+            console.log(`No ${this.assistant} packs configured`);
+            return;
+        }
+        if (options.all) {
+            // Count packs for this assistant
+            const count = editor.packs.filter(p => p.type === this.assistant).length;
+            if (count === 0) {
+                console.log(`No ${this.assistant} packs found`);
+                return;
+            }
+            const errors = await editor.clearAll(this.assistant);
+            console.log(`✓ Cleared all ${this.assistant} packs (${count} removed)`);
+            if (errors.length > 0) {
+                console.warn(`⚠ Warning: Could not delete ${errors.length} prompt file(s)`);
+                for (const error of errors) {
+                    console.warn(`  ${error.message}`);
+                }
+            }
+        }
+        else {
+            const result = await editor.clear(this.assistant);
+            if (result === false) {
+                console.log(`No ${this.assistant} primary pack found`);
+                return;
+            }
+            console.log(`✓ Cleared ${this.assistant} primary pack`);
+            if (result !== true) {
+                console.warn(`⚠ Warning: Could not delete prompt file: ${result.message}`);
+            }
+        }
+    }
+    create() {
+        const command = new Command('clear');
+        command
+            .description(`Clear primary pack for ${this.assistant}`)
+            .option('-a, --all', 'Also remove all agents/skills')
+            .action(async (options) => await this.run(options));
+        return command;
+    }
+}

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

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { AssistantSetCommand } from './assistant-set.js';
+import { AssistantClearCommand } from './assistant-clear.js';
+vi.mock('../config-helpers.js', () => ({
+    loadProjectConfigEditor: vi.fn(),
+    validatePackName: vi.fn()
+}));
+describe('AssistantSetCommand', () => {
+    let command;
+    let helpers;
+    let mockEditor;
+    let consoleErrorSpy;
+    let consoleLogSpy;
+    let processExitSpy;
+    beforeEach(async () => {
+        helpers = await import('../config-helpers.js');
+        vi.clearAllMocks();
+        mockEditor = {
+            packs: [],
+            set: vi.fn()
+        };
+        vi.mocked(helpers.loadProjectConfigEditor).mockResolvedValue(mockEditor);
+        vi.mocked(helpers.validatePackName).mockReturnValue(true);
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+        command = new AssistantSetCommand('copilot');
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+        processExitSpy.mockRestore();
+    });
+    describe('run', () => {
+        it('should set assistant pack', async () => {
+            await command.run('owner/pack/latest', {});
+            expect(helpers.validatePackName).toHaveBeenCalledWith('owner/pack/latest');
+            expect(mockEditor.set).toHaveBeenCalledWith({
+                assistant: 'copilot',
+                pack: 'owner/pack/latest',
+                environment: undefined
+            });
+            expect(consoleLogSpy).toHaveBeenCalledWith('✓ copilot primary pack set to owner/pack/latest');
+        });
+        it('should exit with error on invalid pack name', async () => {
+            vi.mocked(helpers.validatePackName).mockReturnValue(false);
+            await command.run('invalid-pack', {});
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Error: Invalid pack name: invalid-pack');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+            expect(mockEditor.set).not.toHaveBeenCalled();
+        });
+    });
+});
+describe('AssistantClearCommand', () => {
+    let command;
+    let helpers;
+    let mockEditor;
+    let consoleLogSpy;
+    let consoleWarnSpy;
+    beforeEach(async () => {
+        helpers = await import('../config-helpers.js');
+        vi.clearAllMocks();
+        mockEditor = {
+            packs: [{ type: 'copilot', pack: 'owner/pack/latest' }],
+            clear: vi.fn(),
+            clearAll: vi.fn()
+        };
+        vi.mocked(helpers.loadProjectConfigEditor).mockResolvedValue(mockEditor);
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        command = new AssistantClearCommand('copilot');
+    });
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+    });
+    describe('run', () => {
+        it('should clear root pack', async () => {
+            vi.mocked(mockEditor.clear).mockResolvedValue(true);
+            await command.run({});
+            expect(mockEditor.clear).toHaveBeenCalledWith('copilot');
+            expect(consoleLogSpy).toHaveBeenCalledWith('✓ Cleared copilot primary pack');
+        });
+        it('should clear all packs with --all', async () => {
+            vi.mocked(mockEditor.clearAll).mockResolvedValue([]);
+            await command.run({ all: true });
+            expect(mockEditor.clearAll).toHaveBeenCalledWith('copilot');
+            expect(consoleLogSpy).toHaveBeenCalledWith('✓ Cleared all copilot packs (1 removed)');
+        });
+        it('should warn on file deletion errors', async () => {
+            const error = new Error('File not found');
+            vi.mocked(mockEditor.clear).mockResolvedValue(error);
+            await command.run({});
+            expect(consoleWarnSpy).toHaveBeenCalledWith('⚠ Warning: Could not delete prompt file: File not found');
+        });
+    });
+});

package/dist/commands/assistant-set.js

@@ -0,0 +1,38 @@
+import { Command, Option } from 'commander';
+import { loadProjectConfigEditor, validatePackName } from '../config-helpers.js';
+export class AssistantSetCommand {
+    assistant;
+    static envOption = new Option('-e, --environment [env]')
+        .choices(['production', 'development', 'local'])
+        .env('SYSPROMPTHUB_ENVIRONMENT');
+    constructor(assistant) {
+        this.assistant = assistant;
+    }
+    async run(pack, options) {
+        // Validate pack format
+        if (!validatePackName(pack)) {
+            console.error(`Error: Invalid pack name: ${pack}`);
+            console.error('Expected format: owner/pack/version');
+            process.exit(1);
+            return;
+        }
+        // Load project config editor
+        const editor = await loadProjectConfigEditor();
+        // Set the pack using editor
+        await editor.set({
+            assistant: this.assistant,
+            pack,
+            environment: options.environment
+        });
+        console.log(`✓ ${this.assistant} primary pack set to ${pack}`);
+    }
+    create() {
+        const command = new Command('set');
+        command
+            .description(`Set primary pack for ${this.assistant}`)
+            .argument('<pack>', 'Pack name (owner/pack/version)')
+            .addOption(AssistantSetCommand.envOption)
+            .action(async (pack, options) => await this.run(pack, options));
+        return command;
+    }
+}

package/dist/commands/base-command.js

@@ -1,6 +1,7 @@
 import { Option } from "commander";
 export class BaseCommand {
     static envOption = new Option('-e, --environment [env]')
+        .hideHelp()
         .choices(['production', 'development', 'local'])
         .env('SYSPROMPTHUB_ENVIRONMENT');
 }

package/dist/commands/claude.js

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { AssistantSetCommand } from './assistant-set.js';
+import { AssistantClearCommand } from './assistant-clear.js';
+import { AgentAddCommand } from './agent-add.js';
+import { AgentRemoveCommand } from './agent-remove.js';
+export function createClaudeCommand() {
+    const claude = new Command('claude');
+    claude.description('Manage Claude configuration');
+    // Add set/clear commands
+    const setCmd = new AssistantSetCommand('claude');
+    const clearCmd = new AssistantClearCommand('claude');
+    claude.addCommand(setCmd.create());
+    claude.addCommand(clearCmd.create());
+    // Add skill subcommand group
+    const skill = new Command('skill');
+    skill.description('Manage Claude skills');
+    const addCmd = new AgentAddCommand('claude', 'skill');
+    const removeCmd = new AgentRemoveCommand('claude', 'skill');
+    skill.addCommand(addCmd.create());
+    skill.addCommand(removeCmd.create());
+    claude.addCommand(skill);
+    return claude;
+}

package/dist/commands/cli-integration.test.js

@@ -0,0 +1,8 @@
+import { describe, it, expect } from 'vitest';
+// Simple integration test placeholder
+// Full integration tests would require more setup
+describe('CLI Integration', () => {
+    it('placeholder test', () => {
+        expect(true).toBe(true);
+    });
+});

package/dist/commands/copilot.js

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { AssistantSetCommand } from './assistant-set.js';
+import { AssistantClearCommand } from './assistant-clear.js';
+import { AgentAddCommand } from './agent-add.js';
+import { AgentRemoveCommand } from './agent-remove.js';
+export function createCopilotCommand() {
+    const copilot = new Command('copilot');
+    copilot.description('Manage GitHub Copilot configuration');
+    // Add set/clear commands
+    const setCmd = new AssistantSetCommand('copilot');
+    const clearCmd = new AssistantClearCommand('copilot');
+    copilot.addCommand(setCmd.create());
+    copilot.addCommand(clearCmd.create());
+    // Add agent subcommand group
+    const agent = new Command('agent');
+    agent.description('Manage Copilot agents');
+    const addCmd = new AgentAddCommand('copilot', 'agent');
+    const removeCmd = new AgentRemoveCommand('copilot', 'agent');
+    agent.addCommand(addCmd.create());
+    agent.addCommand(removeCmd.create());
+    copilot.addCommand(agent);
+    return copilot;
+}

package/dist/commands/custom-add.js

@@ -0,0 +1,48 @@
+import { Command, Option } from 'commander';
+import { loadProjectConfigEditor, validatePackName } from '../config-helpers.js';
+import { isAbsolute } from 'path';
+import isValidPath from 'is-valid-path';
+export class CustomAddCommand {
+    static envOption = new Option('-e, --environment [env]')
+        .choices(['production', 'development', 'local'])
+        .env('SYSPROMPTHUB_ENVIRONMENT');
+    async run(path, pack, options) {
+        // Validate path
+        if (isAbsolute(path)) {
+            console.error('Error: Path must be relative to the current working directory');
+            process.exit(1);
+            return;
+        }
+        if (!isValidPath(path)) {
+            console.error('Error: Invalid path format');
+            process.exit(1);
+            return;
+        }
+        // Validate pack format
+        if (!validatePackName(pack)) {
+            console.error(`Error: Invalid pack name: ${pack}`);
+            console.error('Expected format: owner/pack/version');
+            process.exit(1);
+            return;
+        }
+        // Load project config editor
+        const editor = await loadProjectConfigEditor();
+        // Add custom pack using editor
+        await editor.addCustom({
+            path,
+            pack,
+            environment: options.environment
+        });
+        console.log(`✓ Custom pack added: ${path} -> ${pack}`);
+    }
+    create() {
+        const command = new Command('add');
+        command
+            .description('Add a custom path configuration')
+            .argument('<path>', 'Relative path where prompt will be written')
+            .argument('<pack>', 'Pack name (owner/pack/version)')
+            .addOption(CustomAddCommand.envOption)
+            .action(async (path, pack, options) => await this.run(path, pack, options));
+        return command;
+    }
+}