snow-flow 8.37.27 → 8.38.1

package/dist/cli.js

@@ -574,9 +574,10 @@ async function executeSnowCode(objective, options) {
             cliLogger.error('SnowCode CLI not found - install: npm install -g @groeimetai/snow-code');
             return false;
         }
-        // Check for SnowCode config (.snow-code/snow-code.json)
-        const snowcodeConfigPath = (0, path_1.join)(process.cwd(), '.snow-code', 'snow-code.json');
-        if (!(0, fs_2.existsSync)(snowcodeConfigPath)) {
+        // Check for SnowCode config (.snow-code/config.json OR .snow-code/snow-code.json)
+        const snowcodeConfigPath = (0, path_1.join)(process.cwd(), '.snow-code', 'config.json');
+        const snowcodeConfigPathAlt = (0, path_1.join)(process.cwd(), '.snow-code', 'snow-code.json');
+        if (!(0, fs_2.existsSync)(snowcodeConfigPath) && !(0, fs_2.existsSync)(snowcodeConfigPathAlt)) {
             cliLogger.error('SnowCode config not found - run: snow-flow init');
             return false;
         }
@@ -1552,7 +1553,7 @@ program
         await copySnowCodeConfig(targetDir, options.force);
         await copySnowCodeThemes(targetDir, options.force);
         await copySnowCodePackageJson(targetDir, options.force);
-        await copyMCPServerScripts(targetDir, options.force);
+        // copyMCPServerScripts removed - scripts/ directory no longer needed for snow-code
         setupSpinner.stop('Project configured');
         // Verify MCP servers
         if (!options.skipMcp) {
@@ -1561,8 +1562,8 @@ program
             await verifyMCPServers(targetDir);
             mcpSpinner.stop('MCP servers verified');
         }
-        // 🔥 CRITICAL: Sync .mcp.json to .claude/mcp-config.json
-        // This ensures Claude Code can discover all MCP servers
+        // Sync .mcp.json to .snow-code/config.json
+        // This ensures snow-code discovers all MCP servers
         try {
             const syncSpinner = prompts.spinner();
             syncSpinner.start('Syncing MCP configurations');
@@ -1739,46 +1740,20 @@ async function checkAndInstallSnowCode() {
     return false;
 }
 async function createDirectoryStructure(targetDir, force = false) {
+    // Minimal directory structure for snow-code
+    // Legacy directories (.claude, .swarm, .snow-flow, memory, coordination, servicenow, templates, scripts) removed
     const directories = [
-        '.claude', '.claude/commands', '.claude/commands/sparc', '.claude/configs',
-        '.swarm', '.swarm/sessions', '.swarm/agents',
-        '.snow-flow', '.snow-flow/queen', '.snow-flow/memory', '.snow-flow/data', '.snow-flow/queen-test', '.snow-flow/queen-advanced',
-        'memory', 'memory/agents', 'memory/sessions',
-        'coordination', 'coordination/memory_bank', 'coordination/subtasks',
-        'servicenow', 'servicenow/widgets', 'servicenow/workflows', 'servicenow/scripts',
-        'templates', 'templates/widgets', 'templates/workflows',
-        'scripts'
+        '.snow-code',
+        '.snow-code/agent',
+        '.snow-code/command',
+        '.snow-code/plugin'
     ];
     for (const dir of directories) {
         const dirPath = (0, path_1.join)(targetDir, dir);
         await fs_1.promises.mkdir(dirPath, { recursive: true });
     }
 }
-async function createBasicConfig(targetDir) {
-    const claudeConfig = {
-        version: version_js_1.VERSION,
-        name: 'snow-flow',
-        description: 'ServiceNow Multi-Agent Development Framework',
-        created: new Date().toISOString(),
-        features: {
-            swarmCoordination: true,
-            persistentMemory: true, // Queen uses JSON files, MCP tools use in-memory
-            serviceNowIntegration: true,
-            sparcModes: true
-        }
-    };
-    const swarmConfig = {
-        version: version_js_1.VERSION,
-        topology: 'hierarchical',
-        maxAgents: 8,
-        memory: {
-            path: '.swarm/memory',
-            namespace: 'snow-flow'
-        }
-    };
-    await fs_1.promises.writeFile((0, path_1.join)(targetDir, '.claude/config.json'), JSON.stringify(claudeConfig, null, 2));
-    await fs_1.promises.writeFile((0, path_1.join)(targetDir, '.swarm/config.json'), JSON.stringify(swarmConfig, null, 2));
-}
+// createBasicConfig removed - legacy .claude and .swarm configs no longer needed
 async function createReadmeFiles(targetDir, force = false) {
     // Only create README.md if it doesn't exist already
     const readmePath = (0, path_1.join)(targetDir, 'README.md');
@@ -1787,9 +1762,7 @@ async function createReadmeFiles(targetDir, force = false) {
         const { README_TEMPLATE } = await Promise.resolve().then(() => __importStar(require('./templates/readme-template.js')));
         await fs_1.promises.writeFile(readmePath, README_TEMPLATE);
     }
-    // Create sub-directory READMEs
-    await fs_1.promises.writeFile((0, path_1.join)(targetDir, 'memory/agents/README.md'), '# Agent Memory\n\nThis directory contains persistent memory for ServiceNow agents.');
-    await fs_1.promises.writeFile((0, path_1.join)(targetDir, 'servicenow/README.md'), '# ServiceNow Artifacts\n\nThis directory contains generated ServiceNow development artifacts.');
+    // Legacy sub-directory READMEs removed (memory/, servicenow/ directories no longer created)
 }
 // Helper functions
 async function copySnowCodeConfig(targetDir, force = false) {
@@ -2038,16 +2011,16 @@ async function verifyMCPServers(targetDir) {
     const path = require('path');
     const fs = require('fs').promises;
     try {
-        // Read SnowCode configuration - try snow-code.json first (primary), then config.json (fallback)
-        const snowCodeJsonPath = path.join(targetDir, '.snow-code', 'snow-code.json');
+        // Read SnowCode configuration - try config.json first (primary), then snow-code.json (fallback for legacy)
         const configJsonPath = path.join(targetDir, '.snow-code', 'config.json');
+        const snowCodeJsonPath = path.join(targetDir, '.snow-code', 'snow-code.json');
         let configContent;
         try {
-            configContent = await fs.readFile(snowCodeJsonPath, 'utf-8');
+            configContent = await fs.readFile(configJsonPath, 'utf-8');
         }
         catch {
-            // Fallback to config.json if snow-code.json doesn't exist
-            configContent = await fs.readFile(configJsonPath, 'utf-8');
+            // Fallback to snow-code.json for legacy projects
+            configContent = await fs.readFile(snowCodeJsonPath, 'utf-8');
         }
         const config = JSON.parse(configContent);
         if (!config.mcp) {
@@ -2138,96 +2111,10 @@ async function verifyMCPServers(targetDir) {
         // Silent error handling
     }
 }
-async function copyMCPServerScripts(targetDir, force = false) {
-    try {
-        // Determine the snow-flow installation directory (same logic as other copy functions)
-        let snowFlowRoot;
-        const isGlobalInstall = __dirname.includes('node_modules/snow-flow') ||
-            __dirname.includes('node_modules/.pnpm') ||
-            __dirname.includes('npm/snow-flow');
-        if (isGlobalInstall) {
-            const parts = __dirname.split(/node_modules[\/\\]/);
-            snowFlowRoot = parts[0] + 'node_modules/snow-flow';
-        }
-        else {
-            let currentDir = __dirname;
-            while (currentDir !== '/') {
-                try {
-                    const packageJsonPath = (0, path_1.join)(currentDir, 'package.json');
-                    const packageJson = JSON.parse(await fs_1.promises.readFile(packageJsonPath, 'utf-8'));
-                    if (packageJson.name === 'snow-flow') {
-                        snowFlowRoot = currentDir;
-                        break;
-                    }
-                }
-                catch {
-                    // Continue searching up
-                }
-                currentDir = (0, path_1.dirname)(currentDir);
-            }
-            if (!snowFlowRoot) {
-                throw new Error('Could not find snow-flow project root');
-            }
-        }
-        // Find scripts directory
-        const scriptsSourcePaths = [
-            (0, path_1.join)(snowFlowRoot, 'scripts'),
-            (0, path_1.join)(__dirname, '..', 'scripts'),
-            (0, path_1.join)(__dirname, 'scripts')
-        ];
-        let scriptsSourceDir = null;
-        for (const sourcePath of scriptsSourcePaths) {
-            try {
-                await fs_1.promises.access(sourcePath);
-                scriptsSourceDir = sourcePath;
-                break;
-            }
-            catch {
-                // Continue to next path
-            }
-        }
-        if (!scriptsSourceDir) {
-            return;
-        }
-        // Create target scripts directory
-        const scriptsTargetDir = (0, path_1.join)(targetDir, 'scripts');
-        await fs_1.promises.mkdir(scriptsTargetDir, { recursive: true });
-        // Copy specific scripts
-        const scriptFiles = [
-            // 'mcp-server-manager.sh', // REMOVED: MCP servers auto-start via .mcp.json, this script is for dev only
-            'start-snowcode.sh'
-        ];
-        let copiedCount = 0;
-        for (const scriptFile of scriptFiles) {
-            const sourcePath = (0, path_1.join)(scriptsSourceDir, scriptFile);
-            const targetPath = (0, path_1.join)(scriptsTargetDir, scriptFile);
-            try {
-                // Check if file already exists
-                try {
-                    await fs_1.promises.access(targetPath);
-                    if (!force) {
-                        continue;
-                    }
-                }
-                catch {
-                    // File doesn't exist, continue with copy
-                }
-                const content = await fs_1.promises.readFile(sourcePath, 'utf8');
-                await fs_1.promises.writeFile(targetPath, content, { mode: 0o755 }); // Make executable
-                copiedCount++;
-            }
-            catch (error) {
-                // Silent error handling
-            }
-        }
-    }
-    catch (error) {
-        // Silent error handling
-    }
-}
+// copyMCPServerScripts removed - scripts/ directory no longer needed for snow-code
+// snow-code auto-manages MCP servers via .mcp.json and .snow-code/config.json
 async function copyCLAUDEmd(targetDir, force = false) {
     let claudeMdContent = '';
-    let agentsMdContent = '';
     // Determine the snow-flow installation directory for absolute MCP paths
     let snowFlowRoot;
     const isGlobalInstall = __dirname.includes('node_modules/snow-flow') ||
@@ -2260,14 +2147,10 @@ async function copyCLAUDEmd(targetDir, force = false) {
     try {
         // First try to find the CLAUDE.md in the source directory (for global installs)
         const sourceClaudeFiles = [
-            // Try the project root (when running from dist/)
             (0, path_1.join)(__dirname, '..', 'CLAUDE.md'),
-            // Try when running directly from src/
             (0, path_1.join)(__dirname, 'CLAUDE.md'),
-            // Try npm global installation paths
             (0, path_1.join)(__dirname, '..', '..', '..', 'CLAUDE.md'),
             (0, path_1.join)(__dirname, '..', '..', '..', '..', 'CLAUDE.md'),
-            // Try current working directory as fallback
             (0, path_1.join)(process.cwd(), 'CLAUDE.md')
         ];
         let foundSource = false;
@@ -2282,145 +2165,104 @@ async function copyCLAUDEmd(targetDir, force = false) {
             }
         }
         if (!foundSource) {
-            // Import the template from the dedicated file
             const { CLAUDE_MD_TEMPLATE } = await Promise.resolve().then(() => __importStar(require('./templates/claude-md-template.js')));
             claudeMdContent = CLAUDE_MD_TEMPLATE;
         }
-        // Use same content for AGENTS.md as CLAUDE.md (they should be identical)
-        agentsMdContent = claudeMdContent;
-        // Create CLAUDE.md (primary instructions for Claude Code)
-        const claudeMdPath = (0, path_1.join)(targetDir, 'CLAUDE.md');
-        try {
-            await fs_1.promises.access(claudeMdPath);
-            if (force) {
-                await fs_1.promises.writeFile(claudeMdPath, claudeMdContent);
-            }
-        }
-        catch {
-            await fs_1.promises.writeFile(claudeMdPath, claudeMdContent);
-        }
-        // Create AGENTS.md (identical copy for SnowCode compatibility)
+        // Create AGENTS.md in root (snow-code searches for AGENTS.md or CLAUDE.md)
         const agentsMdPath = (0, path_1.join)(targetDir, 'AGENTS.md');
         try {
             await fs_1.promises.access(agentsMdPath);
             if (force) {
-                await fs_1.promises.writeFile(agentsMdPath, agentsMdContent);
+                await fs_1.promises.writeFile(agentsMdPath, claudeMdContent);
             }
         }
         catch {
-            await fs_1.promises.writeFile(agentsMdPath, agentsMdContent);
+            await fs_1.promises.writeFile(agentsMdPath, claudeMdContent);
         }
-        // Create .snow-code/ directory structure
+        // Setup .snow-code/ directory (directories already created by createDirectoryStructure)
         const snowcodeDir = (0, path_1.join)(targetDir, '.snow-code');
-        const agentsDir = (0, path_1.join)(snowcodeDir, 'agent'); // Singular 'agent' as required by SnowCode
-        const modesDir = (0, path_1.join)(snowcodeDir, 'modes');
+        const agentsDir = (0, path_1.join)(snowcodeDir, 'agent');
+        // Copy agent files from .snow-code/agent/ in snow-flow package
+        const sourceAgentsDir = (0, path_1.join)(snowFlowRoot, '.snow-code', 'agent');
         try {
-            await fs_1.promises.mkdir(snowcodeDir, { recursive: true });
-            await fs_1.promises.mkdir(agentsDir, { recursive: true });
-            await fs_1.promises.mkdir(modesDir, { recursive: true });
-            // Copy agent files from .claude/ to .snow-code/agent/ (if they exist)
-            const sourceAgentsDir = (0, path_1.join)(__dirname, '..', '.claude', 'agents');
-            try {
-                const agentFiles = await fs_1.promises.readdir(sourceAgentsDir);
-                for (const file of agentFiles) {
-                    if (file.endsWith('.md')) {
-                        const sourceFile = (0, path_1.join)(sourceAgentsDir, file);
-                        const targetFile = (0, path_1.join)(agentsDir, file);
+            const agentFiles = await fs_1.promises.readdir(sourceAgentsDir);
+            for (const file of agentFiles) {
+                if (file.endsWith('.md')) {
+                    const sourceFile = (0, path_1.join)(sourceAgentsDir, file);
+                    const targetFile = (0, path_1.join)(agentsDir, file);
+                    try {
+                        await fs_1.promises.access(targetFile);
+                        if (force) {
+                            const content = await fs_1.promises.readFile(sourceFile, 'utf-8');
+                            await fs_1.promises.writeFile(targetFile, content);
+                        }
+                    }
+                    catch {
                         const content = await fs_1.promises.readFile(sourceFile, 'utf-8');
                         await fs_1.promises.writeFile(targetFile, content);
                     }
                 }
             }
-            catch (err) {
-                // Silently continue - agent configs are in snow-code.json, not separate files
-            }
-            // Create .snow-code/snow-code.json by converting from .mcp.json.template
-            // SINGLE SOURCE OF TRUTH: .mcp.json.template → both Claude and SnowCode formats
-            // CRITICAL: SnowCode/OpenCode does NOT auto-expand ${...} variables
-            // 🔧 Read actual environment values from .env file
-            const envPath = (0, path_1.join)(targetDir, '.env');
-            const envValues = {};
-            try {
-                const envContent = await fs_1.promises.readFile(envPath, 'utf-8');
-                // Parse .env file (simple parser - handles KEY=VALUE lines)
-                const lines = envContent.split('\n');
-                for (var line of lines) {
-                    line = line.trim();
-                    // Skip comments and empty lines
-                    if (!line || line.startsWith('#'))
-                        continue;
-                    var equalIndex = line.indexOf('=');
-                    if (equalIndex > 0) {
-                        var key = line.substring(0, equalIndex).trim();
-                        var value = line.substring(equalIndex + 1).trim();
-                        // Remove quotes if present
-                        if ((value.startsWith('"') && value.endsWith('"')) ||
-                            (value.startsWith("'") && value.endsWith("'"))) {
-                            value = value.substring(1, value.length - 1);
-                        }
-                        envValues[key] = value;
+        }
+        catch (err) {
+            // Silently continue - agent files are optional
+        }
+        // Create .snow-code/config.json from .mcp.json.template
+        const envPath = (0, path_1.join)(targetDir, '.env');
+        const envValues = {};
+        try {
+            const envContent = await fs_1.promises.readFile(envPath, 'utf-8');
+            const lines = envContent.split('\n');
+            for (var line of lines) {
+                line = line.trim();
+                if (!line || line.startsWith('#'))
+                    continue;
+                var equalIndex = line.indexOf('=');
+                if (equalIndex > 0) {
+                    var key = line.substring(0, equalIndex).trim();
+                    var value = line.substring(equalIndex + 1).trim();
+                    if ((value.startsWith('"') && value.endsWith('"')) ||
+                        (value.startsWith("'") && value.endsWith("'"))) {
+                        value = value.substring(1, value.length - 1);
                     }
+                    envValues[key] = value;
                 }
             }
-            catch (error) {
-                // Silent error handling
-            }
-            // Helper function to get env value with proper URL formatting
-            function getEnvValue(key, defaultValue = '') {
-                var value = envValues[key] || process.env[key] || defaultValue;
-                // Special handling for SNOW_INSTANCE - ensure it's a full URL
-                if (key === 'SNOW_INSTANCE' && value && !value.startsWith('http')) {
-                    value = 'https://' + value.replace(/^https?:\/\//, '');
-                }
-                return value;
-            }
-            // Read .mcp.json.template (single source of truth for MCP servers)
-            const mcpTemplatePath = (0, path_1.join)(snowFlowRoot, '.mcp.json.template');
-            let mcpTemplateContent;
-            try {
-                mcpTemplateContent = await fs_1.promises.readFile(mcpTemplatePath, 'utf-8');
-            }
-            catch (error) {
-                throw error;
-            }
-            // Replace placeholders with ACTUAL values from .env (not ${...} syntax!)
-            const mcpConfigContent = mcpTemplateContent
-                .replace(/{{PROJECT_ROOT}}/g, snowFlowRoot)
-                .replace(/{{SNOW_INSTANCE}}/g, getEnvValue('SNOW_INSTANCE'))
-                .replace(/{{SNOW_CLIENT_ID}}/g, getEnvValue('SNOW_CLIENT_ID'))
-                .replace(/{{SNOW_CLIENT_SECRET}}/g, getEnvValue('SNOW_CLIENT_SECRET'))
-                .replace(/{{SNOW_FLOW_ENV}}/g, getEnvValue('SNOW_FLOW_ENV', 'development'));
-            const claudeConfig = JSON.parse(mcpConfigContent);
-            // Convert Claude Desktop format to SnowCode format
-            const snowcodeConfig = convertToSnowCodeFormat(claudeConfig);
-            // Write snow-code.json (SnowCode searches for this name!)
-            // ✅ PROJECT-SCOPED: Only write to project .snow-code/ directory
-            const snowCodeJsonPath = (0, path_1.join)(snowcodeDir, 'snow-code.json');
-            const configJsonPath = (0, path_1.join)(snowcodeDir, 'config.json');
-            await fs_1.promises.writeFile(snowCodeJsonPath, JSON.stringify(snowcodeConfig, null, 2));
-            await fs_1.promises.writeFile(configJsonPath, JSON.stringify(snowcodeConfig, null, 2));
-            // ❌ REMOVED: Global config write
-            // We do NOT write to ~/.config/snow-code/ anymore
-            // Each snow-flow project maintains its own isolated SnowCode configuration
-            // SnowCode will automatically discover and use the project-level .snow-code/ config
-            // Also create AGENTS.md in .snow-code/
-            const snowcodeAgentsMdPath = (0, path_1.join)(snowcodeDir, 'AGENTS.md');
-            await fs_1.promises.writeFile(snowcodeAgentsMdPath, agentsMdContent);
         }
         catch (error) {
             // Silent error handling
         }
+        function getEnvValue(key, defaultValue = '') {
+            var value = envValues[key] || process.env[key] || defaultValue;
+            if (key === 'SNOW_INSTANCE' && value && !value.startsWith('http')) {
+                value = 'https://' + value.replace(/^https?:\/\//, '');
+            }
+            return value;
+        }
+        const mcpTemplatePath = (0, path_1.join)(snowFlowRoot, '.mcp.json.template');
+        let mcpTemplateContent;
+        try {
+            mcpTemplateContent = await fs_1.promises.readFile(mcpTemplatePath, 'utf-8');
+        }
+        catch (error) {
+            throw error;
+        }
+        const mcpConfigContent = mcpTemplateContent
+            .replace(/{{PROJECT_ROOT}}/g, snowFlowRoot)
+            .replace(/{{SNOW_INSTANCE}}/g, getEnvValue('SNOW_INSTANCE'))
+            .replace(/{{SNOW_CLIENT_ID}}/g, getEnvValue('SNOW_CLIENT_ID'))
+            .replace(/{{SNOW_CLIENT_SECRET}}/g, getEnvValue('SNOW_CLIENT_SECRET'))
+            .replace(/{{SNOW_FLOW_ENV}}/g, getEnvValue('SNOW_FLOW_ENV', 'development'));
+        const mcpConfig = JSON.parse(mcpConfigContent);
+        const snowcodeConfig = convertToSnowCodeFormat(mcpConfig);
+        // Write only config.json (snow-code reads this)
+        const configJsonPath = (0, path_1.join)(snowcodeDir, 'config.json');
+        await fs_1.promises.writeFile(configJsonPath, JSON.stringify(snowcodeConfig, null, 2));
     }
     catch (error) {
-        // Silent error handling
-        // Import the template as fallback
+        // Fallback: create minimal AGENTS.md
         const { CLAUDE_MD_TEMPLATE } = await Promise.resolve().then(() => __importStar(require('./templates/claude-md-template.js')));
-        const claudeMdPath = (0, path_1.join)(targetDir, 'CLAUDE.md');
         const agentsMdPath = (0, path_1.join)(targetDir, 'AGENTS.md');
-        if (force || !(0, fs_2.existsSync)(claudeMdPath)) {
-            await fs_1.promises.writeFile(claudeMdPath, CLAUDE_MD_TEMPLATE);
-        }
-        // Use same content for AGENTS.md (they should be identical)
         if (force || !(0, fs_2.existsSync)(agentsMdPath)) {
             await fs_1.promises.writeFile(agentsMdPath, CLAUDE_MD_TEMPLATE);
         }
@@ -2524,7 +2366,7 @@ async function appendToEnvFile(targetDir, content) {
 }
 /**
  * Converts Claude Desktop MCP config format to SnowCode/OpenCode format
- * Single source of truth: .mcp.json.template → both .mcp.json and .snow-code/snow-code.json
+ * Single source of truth: .mcp.json.template → both .mcp.json and .snow-code/config.json
  */
 function convertToSnowCodeFormat(claudeConfig) {
     const snowcodeConfig = {
@@ -2670,7 +2512,7 @@ async function createMCPConfig(targetDir, force = false) {
     // Keep the standard MCP structure that snow-code expects
     // Use the snow-code MCP structure directly from template (mcp key)
     const finalConfig = mcpConfig;
-    // Create .mcp.json in project root for Claude Code discovery
+    // Create .mcp.json in project root (snow-code reads this directly)
     const mcpConfigPath = (0, path_1.join)(targetDir, '.mcp.json');
     try {
         await fs_1.promises.access(mcpConfigPath);
@@ -2685,13 +2527,10 @@ async function createMCPConfig(targetDir, force = false) {
     catch {
         await fs_1.promises.writeFile(mcpConfigPath, JSON.stringify(finalConfig, null, 2));
     }
-    // Also create legacy config in .claude for backward compatibility
-    const legacyConfigPath = (0, path_1.join)(targetDir, '.claude/mcp-config.json');
-    await fs_1.promises.writeFile(legacyConfigPath, JSON.stringify(finalConfig, null, 2));
+    // .claude/mcp-config.json removed - snow-code is the only supported client
     // ✅ PROJECT-SCOPED MCP CONFIG ONLY
-    // We do NOT modify global Snow-Code config (~/.snow-code/snow-code.json)
     // Each project maintains its own isolated MCP configuration in .mcp.json
-    // SnowCode/Claude Code will automatically discover and use the project-level .mcp.json
+    // snow-code automatically discovers and uses the project-level .mcp.json
     // Create comprehensive Claude Code settings file
     // NOTE: Only include properties that Claude Code actually accepts
     // Valid properties: apiKeyHelper, cleanupPeriodDays, env, includeCoAuthoredBy,
@@ -2889,8 +2728,10 @@ async function createMCPConfig(targetDir, force = false) {
         // Snow-Flow v3.5.13+ optimized settings with servicenow-local-development
         // Comprehensive permissions for Snow-Flow development workflow
     };
-    const claudeSettingsPath = (0, path_1.join)(targetDir, '.claude/settings.json');
-    await fs_1.promises.writeFile(claudeSettingsPath, JSON.stringify(claudeSettings, null, 2));
+    // .claude/settings.json removed - snow-code doesn't use this format
+    // snow-code uses .snow-code/config.json for all configuration
+    // Keeping claudeSettings object for potential future snow-code config migration
+    void claudeSettings; // Suppress unused variable warning
 }
 // Setup MCP configuration function
 async function setupMCPConfig(targetDir, instanceUrl, clientId, clientSecret, force = false) {
@@ -3054,13 +2895,10 @@ async function setupMCPConfig(targetDir, instanceUrl, clientId, clientSecret, fo
     catch {
         await fs_1.promises.writeFile(mcpConfigPath, JSON.stringify(finalConfig, null, 2));
     }
-    // Also create legacy config in .claude for backward compatibility
-    const legacyConfigPath = (0, path_1.join)(targetDir, '.claude/mcp-config.json');
-    await fs_1.promises.writeFile(legacyConfigPath, JSON.stringify(finalConfig, null, 2));
-    // 🔧 CRITICAL FIX: Also update global SnowCode configuration
-    // SnowCode/OpenCode reads from ~/.snowcode/snowcode.json
-    const snowcodeConfigPath = (0, path_1.join)(process.env.HOME || '', '.snow-code', 'snow-code.json');
-    const snowcodeConfigDirPath = (0, path_1.join)(process.env.HOME || '', '.snow-code');
+    // .claude/mcp-config.json removed - snow-code is the only supported client
+    // Update project-level .snow-code/config.json
+    const snowcodeConfigPath = (0, path_1.join)(targetDir, '.snow-code', 'config.json');
+    const snowcodeConfigDirPath = (0, path_1.join)(targetDir, '.snow-code');
     try {
         // Ensure directory exists
         try {
@@ -3157,7 +2995,7 @@ async function setupMCPConfig(targetDir, instanceUrl, clientId, clientSecret, fo
         prompts.log.message(`   Servers: ${Object.keys(snowcodeConfig.mcp).join(', ')}`);
         // 🔥 ALSO write LOCAL config (takes priority!)
         const localSnowcodeDir = (0, path_1.join)(targetDir, '.snow-code');
-        const localSnowcodePath = (0, path_1.join)(localSnowcodeDir, 'snow-code.json');
+        const localSnowcodePath = (0, path_1.join)(localSnowcodeDir, 'config.json');
         try {
             // Ensure local .snow-code directory exists
             await fs_1.promises.mkdir(localSnowcodeDir, { recursive: true });