@siemens/ix-mcp-angular 3.2.0-v.1.7.0

package/dist/src/setup.js

@@ -0,0 +1,718 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import chalk from 'chalk';
+import which from 'which';
+import * as jsonc from 'jsonc-parser';
+import { confirmPrompt, multiSelectPrompt, passwordPrompt, showSuccess, showError, showWarning, showInfo } from './prompt.js';
+import { setToken, getToken } from './token.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import { loadConfig } from './config.js';
+const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class SDLMCPSetup {
+    config = loadConfig();
+    repoRoot = this.findRepoRoot();
+    setupOptions = [
+        {
+            title: 'Local VS Code / GitHub Copilot (Repository)',
+            value: 'local-vscode',
+            description: 'Creates .vscode/mcp.json in current repository (recommended for teams)',
+            selected: true
+        },
+        {
+            title: 'Cline Global Settings',
+            value: 'cline-global',
+            description: 'Sets up Cline MCP configuration globally for your user, you should maybe have this package installed globally (as well)'
+        },
+        {
+            title: 'VS Code / GitHub Copilot Global Config',
+            value: 'vscode-user',
+            description: 'Sets up VS Code user-level MCP configuration globally, you should maybe have this package installed globally (as well)'
+        },
+        {
+            title: 'Zed Global Settings',
+            value: 'zed-settings',
+            description: 'Sets up Zed editor / agent MCP configuration globally, you should maybe have this package installed globally (as well)'
+        }
+    ];
+    getRepoConfigOptions() {
+        if (!this.config.agentsFile) {
+            throw new Error('Agent instruction file setup is not enabled for this package.');
+        }
+        if (!this.config.instructionFileName) {
+            throw new Error('Instruction file name is not defined in the configuration.');
+        }
+        return [
+            {
+                title: `Isolated GitHub Copilot Instructions (.github/instructions/${this.config.instructionFileName /* Element.instructions.md */})`,
+                value: 'isolated-instructions',
+                description: 'Recommended: Create isolated instructions for GitHub Copilot (so you can add yours separately)',
+                defaultPath: `.github/instructions/${this.config.instructionFileName /* Element.instructions.md */}`,
+                selected: true
+            },
+            {
+                title: 'AGENTS.md (Repository root)',
+                value: 'agents-md',
+                description: 'Create AGENTS.md in the repository root for general AI agent instructions (does not allow you to add your own instructions)',
+                defaultPath: 'AGENTS.md'
+            },
+            {
+                title: 'General Copilot Instructions (.github/copilot-instructions.md)',
+                value: 'copilot-instructions',
+                description: 'Create the general copilot-instructions.md for GitHub Copilot and other agents (does not allow you to add your own instructions)',
+                defaultPath: '.github/copilot-instructions.md'
+            }
+        ];
+    }
+    findRepoRoot() {
+        let currentDir = process.cwd();
+        while (currentDir !== path.dirname(currentDir)) {
+            if (fs.existsSync(path.join(currentDir, '.git')) || fs.existsSync(path.join(currentDir, 'package.json'))) {
+                return currentDir;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        return process.cwd();
+    }
+    isInstalledInProject() {
+        try {
+            const packageJsonPath = path.join(__dirname, '../../package.json');
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            const packageName = packageJson.name;
+            const projectPackageJsonPath = path.join(this.repoRoot, 'package.json');
+            if (!fs.existsSync(projectPackageJsonPath)) {
+                return false;
+            }
+            const projectPackageJson = JSON.parse(fs.readFileSync(projectPackageJsonPath, 'utf8'));
+            return !!((projectPackageJson.dependencies && projectPackageJson.dependencies[packageName]) ||
+                (projectPackageJson.devDependencies && projectPackageJson.devDependencies[packageName]) ||
+                (projectPackageJson.optionalDependencies && projectPackageJson.optionalDependencies[packageName]));
+        }
+        catch {
+            return false;
+        }
+    }
+    getConfigPaths() {
+        const platform = os.platform();
+        const homeDir = os.homedir();
+        const paths = {
+            clineGlobal: '',
+            vscodeUser: '',
+            zedSettings: ''
+        };
+        switch (platform) {
+            case 'darwin':
+                paths.clineGlobal = path.join(homeDir, 'Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings');
+                paths.vscodeUser = path.join(homeDir, 'Library/Application Support/Code/User');
+                paths.zedSettings = path.join(homeDir, '.config/zed/settings.json');
+                break;
+            case 'linux':
+                paths.clineGlobal = path.join(homeDir, '.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings');
+                paths.vscodeUser = path.join(homeDir, '.config/Code/User');
+                paths.zedSettings = path.join(homeDir, '.config/zed/settings.json');
+                break;
+            case 'win32':
+                paths.clineGlobal = path.join(homeDir, 'AppData/Roaming/Code/User/globalStorage/saoudrizwan.claude-dev/settings');
+                paths.vscodeUser = path.join(homeDir, 'AppData/Roaming/Code/User');
+                paths.zedSettings = path.join(homeDir, 'AppData/Roaming/Zed/settings.json');
+                break;
+            default:
+                throw new Error(`Unsupported platform: ${platform}`);
+        }
+        return paths;
+    }
+    updateJsonWithComments(filePath, updates, defaultConfig, allowNewFile = true) {
+        let content = '';
+        let parsedConfig;
+        if (fs.existsSync(filePath)) {
+            content = fs.readFileSync(filePath, 'utf8');
+            try {
+                parsedConfig = jsonc.parse(content) || defaultConfig;
+            }
+            catch (error) {
+                throw new Error(`Failed to parse JSON file: ${error}`);
+            }
+        }
+        else {
+            if (!allowNewFile) {
+                throw new Error(`Configuration file does not exist: ${filePath}`);
+            }
+            parsedConfig = defaultConfig;
+            content = JSON.stringify(defaultConfig, null, 2);
+        }
+        // If file exists and has content, try to preserve formatting and comments
+        if (content.trim()) {
+            try {
+                let modifiedContent = content;
+                // Apply each update sequentially to preserve comments
+                for (const update of updates) {
+                    // Check if the path exists, if not create the parent structure
+                    const parentPath = update.path.slice(0, -1);
+                    // Ensure parent path exists
+                    if (parentPath.length > 0) {
+                        const tree = jsonc.parseTree(modifiedContent);
+                        if (!tree) {
+                            throw new Error('Failed to parse JSON content into tree structure.');
+                        }
+                        const parentNode = jsonc.findNodeAtLocation(tree, parentPath);
+                        if (!parentNode) {
+                            // Create parent structure
+                            const edits = jsonc.modify(modifiedContent, parentPath, {}, {
+                                formattingOptions: {
+                                    insertSpaces: true,
+                                    tabSize: 2
+                                }
+                            });
+                            modifiedContent = jsonc.applyEdits(modifiedContent, edits);
+                        }
+                    }
+                    // Now set the actual value
+                    const edits = jsonc.modify(modifiedContent, update.path, update.value, {
+                        formattingOptions: {
+                            insertSpaces: true,
+                            tabSize: 2
+                        }
+                    });
+                    modifiedContent = jsonc.applyEdits(modifiedContent, edits);
+                }
+                fs.writeFileSync(filePath, modifiedContent);
+            }
+            catch {
+                showError('Could not update, skipping to avoid corruption.');
+            }
+        }
+        else {
+            // New file - apply updates to default config and use JSON stringify
+            for (const update of updates) {
+                this.setNestedValue(parsedConfig, update.path, update.value);
+            }
+            fs.writeFileSync(filePath, JSON.stringify(parsedConfig, null, 2));
+        }
+    }
+    setNestedValue(obj, path, value) {
+        let current = obj;
+        for (let i = 0; i < path.length - 1; i++) {
+            const key = path[i];
+            if (!(key in current) || typeof current[key] !== 'object' || Array.isArray(current[key])) {
+                current[key] = {};
+            }
+            current = current[key];
+        }
+        current[path[path.length - 1]] = value;
+    }
+    async setupMCPConfigs() {
+        console.log(chalk.bold.blue(`\n${this.config.projectName /* 'Element' */} MCP Setup\n`));
+        showInfo(`Repository root: ${this.repoRoot}`);
+        console.log();
+        console.log(chalk.gray(`This will set up  ${this.config.projectName /* 'Element' */} MCP server configurations for your AI tools.`));
+        console.log(chalk.gray('You can select multiple options to configure different tools at once.\n'));
+        const selectedValues = await multiSelectPrompt('Which tools would you like to configure?', this.setupOptions);
+        if (!selectedValues) {
+            showWarning('No options selected. Setup cancelled.');
+            return;
+        }
+        if (selectedValues.length === 0) {
+            showInfo('No options selected. Nothing to do.');
+            // Offer repository configuration setup
+            const success = await this.setupAgentInstructions();
+            if (success) {
+                this.printUsageInstructions([]);
+            }
+            return;
+        }
+        const selectedOptions = this.setupOptions.filter(option => selectedValues.includes(option.value));
+        console.log();
+        showInfo('Selected configurations:');
+        selectedOptions.forEach(option => {
+            console.log(`  ${chalk.green('•')} ${option.title}`);
+        });
+        console.log();
+        const enableLogging = await confirmPrompt('Enable local logging of search queries and retrieval results?', true);
+        console.log();
+        const proceed = await confirmPrompt('Proceed with setup?', true);
+        if (!proceed) {
+            showWarning('Setup cancelled.');
+            return;
+        }
+        console.log();
+        showInfo('Setting up configurations...');
+        let successCount = 0;
+        for (const option of selectedOptions) {
+            try {
+                switch (option.value) {
+                    case 'local-vscode':
+                        await this.setupLocalVSCodeConfig(enableLogging);
+                        break;
+                    case 'cline-global':
+                        await this.setupClineGlobalConfig(enableLogging);
+                        break;
+                    case 'vscode-user':
+                        await this.setupVSCodeUserConfig(enableLogging);
+                        break;
+                    case 'zed-settings':
+                        await this.setupZedConfig(enableLogging);
+                        break;
+                }
+                successCount++;
+            }
+            catch (error) {
+                showError(`Failed to setup ${option.title}: ${error}`);
+            }
+        }
+        console.log();
+        if (successCount === selectedOptions.length) {
+            showSuccess(`All ${successCount} configurations set up successfully!`);
+            // Offer repository configuration setup
+            const success = await this.setupAgentInstructions();
+            if (success) {
+                this.printUsageInstructions(selectedOptions);
+            }
+        }
+        else {
+            showWarning(`${successCount}/${selectedOptions.length} configurations set up successfully.`);
+        }
+    }
+    async setupToken() {
+        console.log(chalk.bold.blue(`\n${this.config.projectName /* 'Element' */} MCP Token Setup\n`));
+        showInfo(`Setting up LLM token for ${this.config.designSystem /* 'design system' */} documentation access...`);
+        console.log(chalk.gray("Get your token with 'llm' scope from: https://my.siemens.com/"));
+        console.log(chalk.gray('This token is stored securely in your system keychain.\n'));
+        if (process.env.SDL_MCP_TOKEN_ENV === 'true') {
+            showWarning('You are using a token from a environment variable (SDL_MCP_TOKEN_ENV=true), skipping token setup.');
+            if (process.env.OPENAI_API_KEY) {
+                showSuccess('Using OPENAI_API_KEY from environment.');
+                process.exit(0);
+            }
+            else {
+                showError('OPENAI_API_KEY is not set. Please set it.');
+                process.exit(1);
+            }
+        }
+        const hasPrevToken = await getToken();
+        let token;
+        if (hasPrevToken) {
+            token = await passwordPrompt('A token is already configured. Enter a new token to overwrite or leave empty to keep existing:', false);
+        }
+        else {
+            token = await passwordPrompt('Enter your LLM token:');
+        }
+        if (!token && hasPrevToken) {
+            showSuccess('Token stored securely in keychain!');
+            return;
+        }
+        if (!token) {
+            showWarning('Token setup cancelled.');
+            process.exit(1);
+        }
+        try {
+            await setToken(token);
+            showSuccess('Token stored securely in keychain!');
+            showInfo(`Note: Each team member needs to set up their own token using "${this.config.binName /* 'element-mcp' */} setup-token"`);
+        }
+        catch (error) {
+            showError(`Failed to store token: ${error}`);
+            process.exit(1);
+        }
+    }
+    async setupLocalVSCodeConfig(enableLogging = false) {
+        const configDir = path.join(this.repoRoot, '.vscode');
+        const configFile = path.join(configDir, 'mcp.json');
+        await this.ensureDirectoryExists(configDir);
+        const useDevSetup = process.env.SDL_MCP_CONFIG_DEV === 'true';
+        const args = [!useDevSetup ? this.config.name /* '@siemens/element-mcp' */ : path.join('dist', 'src', 'cli.js')];
+        if (enableLogging) {
+            args.push('--log');
+        }
+        const defaultConfig = { servers: {} };
+        const updates = [
+            {
+                path: ['servers', this.config.name /* '@siemens/element-mcp' */],
+                value: {
+                    type: 'stdio',
+                    command: !useDevSetup ? 'npx' : 'node',
+                    args
+                }
+            }
+        ];
+        try {
+            this.updateJsonWithComments(configFile, updates, defaultConfig);
+            showSuccess(`Local VS Code configuration updated`);
+        }
+        catch (error) {
+            showError(`Failed to update VS Code config: ${error}`);
+            throw error;
+        }
+    }
+    async setupClineGlobalConfig(enableLogging = false) {
+        const paths = this.getConfigPaths();
+        const configDir = paths.clineGlobal;
+        const configFile = path.join(configDir, 'cline_mcp_settings.json');
+        await this.ensureDirectoryExists(configDir);
+        const useDevSetup = process.env.SDL_MCP_CONFIG_DEV === 'true';
+        const args = [
+            !useDevSetup ? this.config.name /* '@siemens/element-mcp' */ : path.join(this.repoRoot, 'dist', 'src', 'cli.js')
+        ];
+        if (enableLogging) {
+            args.push('--log');
+        }
+        const defaultConfig = { mcpServers: {} };
+        const updates = [
+            {
+                path: ['mcpServers', this.config.name /* '@siemens/element-mcp' */],
+                value: {
+                    command: !useDevSetup ? 'npx' : 'node',
+                    args
+                }
+            }
+        ];
+        try {
+            this.updateJsonWithComments(configFile, updates, defaultConfig);
+            showSuccess(`Cline global configuration updated`);
+        }
+        catch (error) {
+            showError(`Failed to update Cline config: ${error}`);
+            throw error;
+        }
+    }
+    async setupVSCodeUserConfig(enableLogging = false) {
+        const paths = this.getConfigPaths();
+        const configDir = paths.vscodeUser;
+        const configFile = path.join(configDir, 'mcp.json');
+        await this.ensureDirectoryExists(configDir);
+        const useDevSetup = process.env.SDL_MCP_CONFIG_DEV === 'true';
+        const args = [
+            !useDevSetup ? this.config.name /* '@siemens/element-mcp' */ : path.join(this.repoRoot, 'dist', 'src', 'cli.js')
+        ];
+        if (enableLogging) {
+            args.push('--log');
+        }
+        const defaultConfig = { servers: {} };
+        const updates = [
+            {
+                path: ['servers', this.config.name /* '@siemens/element-mcp' */],
+                value: {
+                    type: 'stdio',
+                    command: !useDevSetup ? 'npx' : 'node',
+                    args
+                }
+            }
+        ];
+        try {
+            this.updateJsonWithComments(configFile, updates, defaultConfig);
+            showSuccess(`VS Code user configuration updated`);
+        }
+        catch (error) {
+            showError(`Failed to update VS Code user config: ${error}`);
+            throw error;
+        }
+    }
+    async setupZedConfig(enableLogging = false) {
+        const paths = this.getConfigPaths();
+        const configFile = paths.zedSettings;
+        const configDir = path.dirname(configFile);
+        await this.ensureDirectoryExists(configDir);
+        // Check if npx is available
+        try {
+            await execAsync('which npx');
+        }
+        catch {
+            showError('npx is not available in PATH. Please install Node.js/npm first.');
+            throw new Error('npx not found');
+        }
+        const useDevSetup = process.env.SDL_MCP_CONFIG_DEV === 'true';
+        const npxPath = await this.findNpxPath();
+        const args = [
+            !useDevSetup ? this.config.name /* '@siemens/element-mcp' */ : path.join(this.repoRoot, 'dist', 'src', 'cli.js')
+        ];
+        if (enableLogging) {
+            args.push('--log');
+        }
+        const defaultConfig = {};
+        const updates = [
+            {
+                path: ['context_servers', this.config.name /* '@siemens/element-mcp' */],
+                value: {
+                    source: 'command',
+                    command: npxPath,
+                    args,
+                    env: {}
+                }
+            }
+        ];
+        try {
+            this.updateJsonWithComments(configFile, updates, defaultConfig);
+            showSuccess(`Zed configuration updated`);
+        }
+        catch (error) {
+            showError(`Failed to update Zed config: ${error}`);
+            throw error;
+        }
+    }
+    async findNpxPath() {
+        try {
+            return (await which('npx')).replaceAll(path.sep, path.posix.sep);
+        }
+        catch {
+            const commonPaths = ['/usr/local/bin/npx', '/usr/bin/npx', 'npx'];
+            for (const path of commonPaths) {
+                try {
+                    await execAsync(`${path} --version`);
+                    return path;
+                }
+                catch {
+                    continue;
+                }
+            }
+            return 'npx';
+        }
+    }
+    async ensureDirectoryExists(dir) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    async checkSetup() {
+        console.log(chalk.bold.blue(`\n${this.config.projectName /* 'Element' */} MCP Setup Status\n`));
+        showInfo(`Repository root: ${this.repoRoot}`);
+        console.log();
+        try {
+            const token = await getToken();
+            if (token) {
+                showSuccess('LLM token is configured');
+            }
+            else {
+                showError(`LLM token not found. Run '${this.config.binName /* 'element-mcp' */} setup-token'`);
+            }
+        }
+        catch (error) {
+            showWarning(`Could not check token: ${error}`);
+        }
+        console.log();
+        console.log(chalk.bold('MCP Configuration Status:'));
+        const paths = this.getConfigPaths();
+        const configs = [
+            {
+                name: 'Local VS Code',
+                path: path.join(this.repoRoot, '.vscode', 'mcp.json')
+            },
+            {
+                name: 'Cline Global Settings',
+                path: paths.clineGlobal
+            },
+            {
+                name: 'VS Code / GitHub Copilot Global Config',
+                path: path.join(paths.vscodeUser, 'mcp.json')
+            },
+            {
+                name: 'Zed Global Settings',
+                path: paths.zedSettings
+            }
+        ];
+        for (const config of configs) {
+            if (fs.existsSync(config.path)) {
+                try {
+                    const content = fs.readFileSync(config.path, 'utf8');
+                    const parsedContent = jsonc.parse(content);
+                    const hasSDLMCP = JSON.stringify(parsedContent).includes(this.config.name /* '@siemens/element-mcp' */);
+                    if (hasSDLMCP) {
+                        showSuccess(`${config.name} MCP configuration found`);
+                    }
+                    else {
+                        showWarning(`${config.name} configuration exists but missing ${this.config.name /* 'MCP' */} server`);
+                    }
+                }
+                catch {
+                    showError(`${config.name} configuration file is corrupted (parse error)`);
+                }
+            }
+            else {
+                showError(`${config.name} MCP configuration not found`);
+            }
+        }
+        console.log();
+        console.log(chalk.bold('Configuration file locations:'));
+        for (const config of configs) {
+            console.log(`  ${chalk.gray(config.name)}: ${config.path}`);
+        }
+    }
+    printUsageInstructions(selectedOptions) {
+        console.log(chalk.bold.green('\nNext Steps\n'));
+        console.log(chalk.bold('IMPORTANT:'), 'Trust and start the MCP server in your AI tools to enable functionality. If you are using a version manager like nvm or asdf, you may need to replace the command with the full path to `npx`, get it by running `which/where npx`.\n');
+        console.log(chalk.bold('Usage Examples:'));
+        this.config.exampleQuestions.forEach((question) => {
+            console.log(chalk.gray(`• "${question}"`));
+        });
+        console.log();
+        selectedOptions.forEach(option => {
+            switch (option.value) {
+                case 'local-vscode':
+                    console.log(chalk.bold('Local VS Code:'));
+                    console.log('  • Commit the .vscode/mcp.json file to your repository');
+                    console.log('  • Share with your team for consistent setup');
+                    console.log('  • Restart VS Code and click "Server" icon in GitHub Copilot Chat\n');
+                    break;
+                case 'cline-global':
+                    console.log(chalk.bold('Cline:'));
+                    console.log('  • Configuration is now set up globally');
+                    console.log('  • Restart Cline to load the new MCP server\n');
+                    break;
+                case 'vscode-user':
+                    console.log(chalk.bold('VS Code User:'));
+                    console.log('  • Configuration is now set up globally for your user');
+                    console.log('  • Restart VS Code and click "Server" icon in GitHub Copilot Chat\n');
+                    break;
+                case 'zed-settings':
+                    console.log(chalk.bold('Zed:'));
+                    console.log('  • Configuration is now set up in your Zed settings');
+                    console.log('  • Restart Zed to load the new MCP server\n');
+                    break;
+            }
+        });
+        showInfo('The MCP server will auto-start when you use it in supported tools.');
+        console.log(chalk.gray(`\nRun this setup command in every project directory where you want to use ${this.config.designSystem /* 'design system' */} documentation search.`));
+    }
+    async setupAgentInstructions() {
+        console.log(chalk.bold.blue('\n\nAI Agent Instruction Setup\n'));
+        const proceed = await confirmPrompt(`Would you like to add instruction files for AI agents to work with ${this.config.designSystem /* 'the design system' */} to your repository (recommended)?`, true);
+        if (!proceed) {
+            showInfo('Skipping AI agent instruction setup.');
+            return true;
+        }
+        console.log(chalk.gray(`These instruction files help AI agents work more effectively with ${this.config.designSystem /* 'the design system' */}.\n`));
+        if (!this.config.agentsFile) {
+            return true;
+        }
+        const repoConfigOptions = this.getRepoConfigOptions();
+        const selectedValues = await multiSelectPrompt('Which instruction file would you like to add?', repoConfigOptions);
+        if (!selectedValues || selectedValues.length === 0) {
+            showInfo('No instruction file selected.');
+            return true;
+        }
+        const selectedOptions = repoConfigOptions.filter(option => selectedValues.includes(option.value));
+        console.log();
+        showInfo('Selected instruction file(s):');
+        selectedOptions.forEach(option => {
+            console.log(`  ${chalk.green('•')} ${option.title}`);
+        });
+        console.log();
+        const isInstalled = this.isInstalledInProject();
+        let useSymlink = false;
+        if (isInstalled) {
+            useSymlink = await confirmPrompt('Use symlinks/aliases? (recommended for getting updates, but requires package to be and stay installed in the package and may not work with some systems or package managers)', true);
+        }
+        else {
+            showInfo(`Package not detected in project dependencies - copying files instead of symlinking. Consider installing ${this.config.name /* 'the MCP package' */} in your project for easier updates.`);
+            useSymlink = false;
+        }
+        console.log();
+        showInfo('Setting up AI agent instruction file(s)...');
+        let successCount = 0;
+        for (const option of selectedOptions) {
+            try {
+                await this.setupInstructionFile(option, useSymlink);
+                successCount++;
+            }
+            catch (error) {
+                showError(`Failed to setup ${option.title}: ${error}`);
+            }
+        }
+        console.log();
+        if (successCount === selectedOptions.length) {
+            showSuccess(`All ${successCount} instruction files set up successfully!`);
+            this.printAgentInstructions(selectedOptions);
+            return true;
+        }
+        else {
+            showWarning(`${successCount}/${selectedOptions.length} instruction files set up successfully.`);
+            return false;
+        }
+    }
+    async setupInstructionFile(option, useSymlink) {
+        const targetPath = path.join(this.repoRoot, option.defaultPath);
+        const targetDir = path.dirname(targetPath);
+        // Ensure target directory exists
+        await this.ensureDirectoryExists(targetDir);
+        // Check if file already exists
+        if (fs.existsSync(targetPath)) {
+            const overwrite = await confirmPrompt(`${option.defaultPath} already exists. Overwrite?`, false);
+            if (!overwrite) {
+                showInfo(`Skipping ${option.title} - file already exists.`);
+                return;
+            }
+        }
+        const sourcePath = path.resolve(path.join(__dirname, '..', '..', 'AGENTS.md'));
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`AGENTS.md file does not exist at ${sourcePath}`);
+        }
+        const content = await fs.promises.readFile(sourcePath, 'utf8');
+        switch (option.value) {
+            case 'isolated-instructions':
+                if (useSymlink) {
+                    await this.createSymlink(sourcePath, targetPath);
+                }
+                else {
+                    await fs.promises.writeFile(targetPath, content, 'utf8');
+                }
+                break;
+            case 'copilot-instructions': {
+                if (useSymlink) {
+                    await this.createSymlink(sourcePath, targetPath);
+                }
+                else {
+                    await fs.promises.writeFile(targetPath, content, 'utf8');
+                }
+                break;
+            }
+            case 'agents-md': {
+                if (useSymlink) {
+                    await this.createSymlink(sourcePath, targetPath);
+                }
+                else {
+                    await fs.promises.writeFile(targetPath, content, 'utf8');
+                }
+                break;
+            }
+        }
+        showSuccess(`${option.title} set up at ${option.defaultPath} ${useSymlink ? '(symlinked)' : '(copied)'}`);
+    }
+    async createSymlink(sourcePath, targetPath) {
+        // Remove existing file/symlink if it exists
+        if (fs.existsSync(targetPath)) {
+            await fs.promises.unlink(targetPath);
+        }
+        await fs.promises.symlink(sourcePath, targetPath);
+    }
+    printAgentInstructions(selectedOptions) {
+        console.log(chalk.bold.green('\nAI Agent Instruction Setup Complete\n'));
+        selectedOptions.forEach(option => {
+            switch (option.value) {
+                case 'isolated-instructions':
+                    console.log(chalk.bold(`${this.config.designSystem /* 'Design System' */} Instructions:`));
+                    console.log(`  • File created at: ${option.defaultPath}`);
+                    break;
+                case 'copilot-instructions':
+                    console.log(chalk.bold('Copilot Instructions:'));
+                    console.log(`  • File created at: ${option.defaultPath}`);
+                    break;
+                case 'agents-md':
+                    console.log(chalk.bold('AGENTS.md:'));
+                    console.log(`  • File created at: ${option.defaultPath}`);
+                    break;
+            }
+        });
+        console.log(chalk.bold('Recommendations:'));
+        console.log(chalk.gray('• Commit these instruction files to share consistent AI behavior with your team'));
+        console.log(chalk.gray('• Symlinked files will update automatically with package updates'));
+        console.log(chalk.gray("• Copied files give you full control but won't receive updates"));
+        console.log(chalk.gray('• .github/instructions/ approach allows multiple specialized instruction files'));
+    }
+}
+//# sourceMappingURL=setup.js.map