@xelth/eck-snapshot 4.2.4 → 5.4.0

package/src/cli/commands/setupMcp.js

@@ -0,0 +1,269 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import os from 'os';
+import { execa } from 'execa';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Setup / Restore MCP servers for Claude Code and OpenCode.
+ * Registers:
+ *   1. eck-core     (eck_finish_task) - commit + snapshot
+ *   2. glm-zai      (glm_zai_*) - GLM-4.7 coding workers
+ *
+ * Usage:
+ *   eck-snapshot setup-mcp              # Auto-detect and register for Claude Code
+ *   eck-snapshot setup-mcp --opencode   # Register for OpenCode
+ *   eck-snapshot setup-mcp --both       # Register for both
+ */
+export async function setupMcp(options = {}) {
+  const packageRoot = path.resolve(__dirname, '../../..');
+  const eckCorePath = path.join(packageRoot, 'scripts', 'mcp-eck-core.js');
+  const glmZaiPath = path.join(packageRoot, 'scripts', 'mcp-glm-zai-worker.mjs');
+  const mcpServerPath = path.join(packageRoot, 'src', 'mcp-server', 'index.js');
+
+  const targets = [];
+  if (options.opencode && !options.both) {
+    targets.push('opencode');
+  } else if (options.both) {
+    targets.push('claude', 'opencode');
+  } else {
+    targets.push('claude');
+  }
+
+  console.log(chalk.blue.bold('\n🔧 EckSnapshot MCP Setup\n'));
+
+  for (const target of targets) {
+    if (target === 'claude') {
+      await setupForClaude(packageRoot, eckCorePath, glmZaiPath, mcpServerPath, options);
+    } else {
+      await setupForOpenCode(packageRoot, eckCorePath, glmZaiPath, options);
+    }
+  }
+
+  // Print summary
+  console.log(chalk.green.bold('\n✅ MCP Setup Complete!\n'));
+  console.log(chalk.white('Registered MCP servers:'));
+  console.log(chalk.cyan('  1. eck-core') + chalk.gray('     → eck_finish_task (commit + snapshot)'));
+  console.log(chalk.cyan('  2. glm-zai') + chalk.gray('      → glm_zai_backend, glm_zai_frontend, glm_zai_qa, glm_zai_refactor, glm_zai_general'));
+  console.log('');
+  console.log(chalk.yellow('Requirements:'));
+  console.log(chalk.white('  • ZAI_API_KEY environment variable must be set for GLM Z.AI workers'));
+  console.log(chalk.white('  • Get your key at https://z.ai'));
+  console.log('');
+  console.log(chalk.yellow('Next steps:'));
+  console.log(chalk.white('  1. Restart your AI coding tool (Claude Code / OpenCode)'));
+  console.log(chalk.white('  2. The tools will be available automatically'));
+  console.log(chalk.white('  3. Use --jas or --jao flags to generate CLAUDE.md with delegation protocol'));
+  console.log('');
+}
+
+/**
+ * Register MCP servers for Claude Code using `claude mcp add`
+ */
+async function setupForClaude(packageRoot, eckCorePath, glmZaiPath, mcpServerPath, options) {
+  const spinner = ora();
+
+  console.log(chalk.blue('📦 Setting up for Claude Code...\n'));
+
+  // Method 1: Try `claude mcp add` commands (preferred)
+  let usedCliRegistration = false;
+
+  try {
+    spinner.start('Checking if `claude` CLI is available...');
+    await execa('claude', ['--version']);
+    spinner.succeed('Claude CLI found');
+
+    // Helper to register a single MCP server via claude CLI
+    async function registerClaudeMcp(name, scriptPath) {
+      spinner.start(`Registering ${name} MCP server...`);
+      try {
+        await execa('claude', ['mcp', 'add', name, '--', 'node', scriptPath]);
+        spinner.succeed(`${name} registered`);
+      } catch (e) {
+        // May already exist - try remove then add
+        try {
+          await execa('claude', ['mcp', 'remove', name]);
+          await execa('claude', ['mcp', 'add', name, '--', 'node', scriptPath]);
+          spinner.succeed(`${name} re-registered`);
+        } catch (e2) {
+          spinner.warn(`${name} registration via CLI failed: ${e2.message}`);
+        }
+      }
+    }
+
+    await registerClaudeMcp('eck-core', eckCorePath);
+    await registerClaudeMcp('glm-zai', glmZaiPath);
+    await registerClaudeMcp('ecksnapshot', mcpServerPath);
+
+    usedCliRegistration = true;
+  } catch {
+    spinner.info('Claude CLI not found, will use config file method');
+  }
+
+  // Method 2: Also update the config file as fallback / alternative
+  spinner.start('Updating Claude Code config file...');
+
+  const homeDir = os.homedir();
+  const platform = process.platform;
+
+  let possibleConfigPaths = [];
+  if (platform === 'win32') {
+    const appData = process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming');
+    possibleConfigPaths = [
+      path.join(appData, 'Claude', 'config.json'),
+      path.join(homeDir, '.claude', 'config.json'),
+      path.join(homeDir, '.config', 'claude', 'config.json'),
+    ];
+  } else {
+    possibleConfigPaths = [
+      path.join(homeDir, '.config', 'claude', 'config.json'),
+      path.join(homeDir, '.claude', 'config.json'),
+    ];
+  }
+
+  let claudeConfigPath = null;
+  for (const configPath of possibleConfigPaths) {
+    try {
+      await fs.access(configPath);
+      claudeConfigPath = configPath;
+      break;
+    } catch { /* continue */ }
+  }
+
+  if (!claudeConfigPath) {
+    claudeConfigPath = possibleConfigPaths[0];
+  }
+
+  let config = {};
+  try {
+    const content = await fs.readFile(claudeConfigPath, 'utf-8');
+    config = JSON.parse(content);
+  } catch { /* new config */ }
+
+  if (!config.mcpServers) config.mcpServers = {};
+
+  config.mcpServers.ecksnapshot = {
+    command: 'node',
+    args: [mcpServerPath],
+    env: {},
+  };
+
+  config.mcpServers['eck-core'] = {
+    command: 'node',
+    args: [eckCorePath],
+    env: {},
+  };
+
+  config.mcpServers['glm-zai'] = {
+    command: 'node',
+    args: [glmZaiPath],
+    env: {},
+  };
+
+  // Remove old minimax-worker if present
+  if (config.mcpServers['minimax-worker']) {
+    delete config.mcpServers['minimax-worker'];
+    console.log(chalk.gray('  Removed old minimax-worker MCP server'));
+  }
+
+  await fs.mkdir(path.dirname(claudeConfigPath), { recursive: true });
+  await fs.writeFile(claudeConfigPath, JSON.stringify(config, null, 2));
+
+  spinner.succeed(`Config saved: ${chalk.cyan(claudeConfigPath)}`);
+
+  // Also update the local .eck/claude-mcp-config.json
+  const localConfigPath = path.join(process.cwd(), '.eck', 'claude-mcp-config.json');
+  const localConfig = {
+    mcpServers: {
+      ecksnapshot: config.mcpServers.ecksnapshot,
+      'eck-core': config.mcpServers['eck-core'],
+      'glm-zai': config.mcpServers['glm-zai'],
+    },
+  };
+
+  try {
+    await fs.mkdir(path.dirname(localConfigPath), { recursive: true });
+    await fs.writeFile(localConfigPath, JSON.stringify(localConfig, null, 2));
+    spinner.succeed(`Local config updated: ${chalk.cyan(localConfigPath)}`);
+  } catch (e) {
+    spinner.warn(`Could not update local config: ${e.message}`);
+  }
+}
+
+/**
+ * Register MCP servers for OpenCode.
+ * OpenCode uses opencode.json at project root with its own format:
+ *   { "mcp": { "name": { "type": "local", "command": [...], "enabled": true } } }
+ * The CLI (`opencode mcp add`) is interactive (TUI), so we write the config directly.
+ */
+async function setupForOpenCode(packageRoot, eckCorePath, glmZaiPath, options) {
+  const spinner = ora();
+
+  console.log(chalk.blue('📦 Setting up for OpenCode...\n'));
+
+  const configPath = path.join(process.cwd(), 'opencode.json');
+
+  spinner.start('Updating OpenCode config (opencode.json)...');
+
+  // Read existing config or create new
+  let config = {};
+  try {
+    const content = await fs.readFile(configPath, 'utf-8');
+    config = JSON.parse(content);
+  } catch { /* new config */ }
+
+  // Ensure $schema and base structure
+  if (!config.$schema) {
+    config.$schema = 'https://opencode.ai/config.json';
+  }
+  if (!config.mcp) {
+    config.mcp = {};
+  }
+
+  // Register eck-core
+  config.mcp['eck-core'] = {
+    type: 'local',
+    command: ['node', eckCorePath],
+    enabled: true,
+    timeout: 30000,
+  };
+
+  // Register glm-zai
+  config.mcp['glm-zai'] = {
+    type: 'local',
+    command: ['node', glmZaiPath],
+    enabled: true,
+    timeout: 120000,
+  };
+
+  // Preserve ZAI_API_KEY in environment if it was set before
+  if (process.env.ZAI_API_KEY) {
+    config.mcp['glm-zai'].environment = {
+      ZAI_API_KEY: process.env.ZAI_API_KEY,
+    };
+  }
+
+  // Remove old minimax entries if present
+  if (config.mcp['minimax-worker']) {
+    delete config.mcp['minimax-worker'];
+    console.log(chalk.gray('  Removed old minimax-worker from opencode.json'));
+  }
+
+  // Ensure AGENTS.md is in instructions
+  if (!config.instructions) {
+    config.instructions = ['AGENTS.md'];
+  } else if (!config.instructions.includes('AGENTS.md')) {
+    config.instructions.push('AGENTS.md');
+  }
+
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+  spinner.succeed(`OpenCode config updated: ${chalk.cyan(configPath)}`);
+
+  console.log(chalk.gray('\n  OpenCode will read MCP servers from opencode.json on next start.'));
+  console.log(chalk.gray('  Use `eck-snapshot --jas` or `--jao` to generate AGENTS.md for OpenCode.\n'));
+}

package/src/cli/commands/showFile.js

@@ -0,0 +1,39 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+
+/**
+ * Show the full content of specific files
+ * Used for AI lazy loading when skeleton mode is active
+ * @param {string[]} filePaths - Array of paths to the files to display
+ */
+export async function showFile(filePaths) {
+    // Ensure input is array (commander passes array for variadic args)
+    const files = Array.isArray(filePaths) ? filePaths : [filePaths];
+
+    if (files.length === 0) {
+        console.error(chalk.yellow('No files specified. Usage: eck-snapshot show <file1> [file2] ...'));
+        return;
+    }
+
+    for (const filePath of files) {
+        try {
+            const fullPath = path.resolve(process.cwd(), filePath);
+            const content = await fs.readFile(fullPath, 'utf-8');
+
+            console.log(chalk.green(`\n--- FULL CONTENT: ${filePath} ---\n`));
+
+            // Detect file extension for syntax highlighting hint
+            const ext = path.extname(filePath).slice(1);
+            console.log('```' + ext);
+            console.log(content);
+            console.log('```');
+
+            console.log(chalk.green(`\n--- END OF FILE: ${filePath} ---\n`));
+
+        } catch (error) {
+            console.error(chalk.red(`Failed to read file ${filePath}: ${error.message}`));
+            // Continue to next file even if one fails
+        }
+    }
+}

package/src/cli/commands/trainTokens.js

@@ -0,0 +1,38 @@
+import { addTrainingPoint, showEstimationStats } from '../../utils/tokenEstimator.js';
+
+/**
+ * Train token estimation with actual results
+ * @param {string} projectType - Type of project (android, nodejs, etc.)
+ * @param {string} fileSizeStr - File size in bytes
+ * @param {string} estimatedStr - Estimated tokens
+ * @param {string} actualStr - Actual tokens (from user input)
+ */
+export async function trainTokens(projectType, fileSizeStr, estimatedStr, actualStr) {
+  try {
+    const fileSizeInBytes = parseInt(fileSizeStr, 10);
+    const estimatedTokens = parseInt(estimatedStr, 10);
+    
+    // Parse actual tokens from user input (remove any text like "tokens", commas, etc.)
+    const actualTokens = parseInt(actualStr.replace(/[^\d]/g, ''), 10);
+    
+    if (isNaN(fileSizeInBytes) || isNaN(estimatedTokens) || isNaN(actualTokens)) {
+      throw new Error('Invalid numeric values provided');
+    }
+    
+    await addTrainingPoint(projectType, fileSizeInBytes, estimatedTokens, actualTokens);
+    
+    console.log('\n📈 Updated polynomial coefficients for improved estimation.');
+    
+  } catch (error) {
+    console.error(`❌ Error training token estimation: ${error.message}`);
+    console.error('Usage: eck-snapshot train-tokens <project-type> <file-size-bytes> <estimated-tokens> <actual-tokens>');
+    process.exit(1);
+  }
+}
+
+/**
+ * Show token estimation statistics
+ */
+export async function showTokenStats() {
+  await showEstimationStats();
+}

package/src/cli/commands/updateSnapshot.js

@@ -0,0 +1,219 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import { getGitAnchor, getChangedFiles, getGitDiffOutput } from '../../utils/gitUtils.js';
+import { loadSetupConfig } from '../../config.js';
+import { readFileWithSizeCheck, parseSize, formatSize, matchesPattern, loadGitignore, generateTimestamp, getShortRepoName } from '../../utils/fileUtils.js';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Shared logic to generate the snapshot content string
+async function generateSnapshotContent(repoPath, changedFiles, anchor, config, gitignore) {
+  let contentOutput = '';
+  let includedCount = 0;
+  const fileList = [];
+
+  // Check for Agent Report in .eck/lastsnapshot/AnswerToSA.md (STRICT LOCATION)
+  const reportPath = path.join(repoPath, '.eck', 'lastsnapshot', 'AnswerToSA.md');
+  let agentReport = null;
+  try {
+    agentReport = await fs.readFile(reportPath, 'utf-8');
+    if (!changedFiles.includes('.eck/lastsnapshot/AnswerToSA.md')) {
+      changedFiles.push('.eck/lastsnapshot/AnswerToSA.md');
+    }
+  } catch (e) { /* No report */ }
+
+  for (const filePath of changedFiles) {
+    if (config.dirsToIgnore.some(d => filePath.startsWith(d))) continue;
+    if (gitignore.ignores(filePath) && filePath !== '.eck/lastsnapshot/AnswerToSA.md') continue;
+
+    try {
+      const fullPath = path.join(repoPath, filePath);
+      const content = await readFileWithSizeCheck(fullPath, parseSize(config.maxFileSize));
+      contentOutput += `--- File: /${filePath} ---\n\n${content}\n\n`;
+      fileList.push(`- ${filePath}`);
+      includedCount++;
+    } catch (e) { /* Skip */ }
+  }
+
+  // Load Template
+  const templatePath = path.join(__dirname, '../../templates/update-prompt.template.md');
+  let header = await fs.readFile(templatePath, 'utf-8');
+
+  // Inject Agent Report
+  let reportSection = '';
+  if (agentReport) {
+    reportSection = `\n#######################################################\n# 📨 MESSAGE FROM EXECUTION AGENT (Claude)\n#######################################################\n${agentReport}\n#######################################################\n\n`;
+  }
+
+  header = header.replace('{{anchor}}', anchor.substring(0, 7))
+    .replace('{{timestamp}}', new Date().toLocaleString())
+    .replace('{{fileList}}', fileList.join('\n'));
+
+  header = reportSection + header;
+
+  const diffOutput = await getGitDiffOutput(repoPath, anchor);
+  const diffSection = `\n--- GIT DIFF (For Context) ---\n\n\`\`\`diff\n${diffOutput}\n\`\`\``;
+
+  return {
+    fullContent: header + contentOutput + diffSection,
+    includedCount,
+    anchor,
+    agentReport
+  };
+}
+
+export async function updateSnapshot(repoPath, options) {
+  const spinner = ora('Generating update snapshot...').start();
+  try {
+    const anchor = await getGitAnchor(repoPath);
+    if (!anchor) {
+      throw new Error('No snapshot anchor found. Run a full snapshot first: eck-snapshot snapshot');
+    }
+
+    const changedFiles = await getChangedFiles(repoPath, anchor);
+    if (changedFiles.length === 0) {
+      spinner.succeed('No changes detected since last full snapshot.');
+      return;
+    }
+
+    const setupConfig = await loadSetupConfig();
+    const config = { ...setupConfig.fileFiltering, ...setupConfig.performance, ...options };
+    const gitignore = await loadGitignore(repoPath);
+
+    const { fullContent, includedCount, agentReport } = await generateSnapshotContent(repoPath, changedFiles, anchor, config, gitignore);
+
+    // Determine sequence number
+    let seqNum = 1;
+    const counterPath = path.join(repoPath, '.eck', 'update_seq');
+    try {
+      const seqData = await fs.readFile(counterPath, 'utf-8');
+      const [savedHash, savedCount] = seqData.split(':');
+      if (savedHash && savedHash.trim() === anchor.substring(0, 7).trim()) {
+        seqNum = parseInt(savedCount || '0') + 1;
+      }
+    } catch (e) {}
+
+    try {
+      await fs.writeFile(counterPath, `${anchor.substring(0, 7)}:${seqNum}`);
+    } catch (e) {}
+
+    const timestamp = generateTimestamp();
+    const shortRepoName = getShortRepoName(path.basename(repoPath));
+    const outputFilename = `eck${shortRepoName}${timestamp}_${anchor.substring(0, 7)}_up${seqNum}.md`;
+    const outputPath = path.join(repoPath, '.eck', 'snapshots', outputFilename);
+
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, fullContent);
+
+    spinner.succeed(`Update snapshot created: .eck/snapshots/${outputFilename}`);
+
+    // --- FEATURE: Active Snapshot (.eck/lastsnapshot/) ---
+    try {
+      const snapDir = path.join(repoPath, '.eck', 'lastsnapshot');
+      await fs.mkdir(snapDir, { recursive: true });
+
+      // 1. Clean up OLD snapshots
+      const existingFiles = await fs.readdir(snapDir);
+      for (const file of existingFiles) {
+        if ((file.startsWith('eck') && file.endsWith('.md')) || file === 'answer.md') {
+          await fs.unlink(path.join(snapDir, file));
+        }
+      }
+
+      // 2. Save new file
+      await fs.writeFile(path.join(snapDir, outputFilename), fullContent);
+      console.log(chalk.cyan(`📋 Active snapshot updated in .eck/lastsnapshot/: ${outputFilename}`));
+    } catch (e) {
+      // Non-critical failure
+    }
+    // --------------------------------------------
+
+    // Check if agent report was included
+    if (agentReport) {
+      console.log(chalk.green('📨 Included Agent Report (.eck/lastsnapshot/AnswerToSA.md)'));
+    }
+
+    console.log(`📦 Included ${includedCount} changed files.`);
+
+  } catch (error) {
+    spinner.fail(`Update failed: ${error.message}`);
+  }
+}
+
+// New Silent/JSON command for Agents
+export async function updateSnapshotJson(repoPath) {
+  try {
+    const anchor = await getGitAnchor(repoPath);
+    if (!anchor) {
+      console.log(JSON.stringify({ status: "error", message: "No snapshot anchor found" }));
+      return;
+    }
+
+    const changedFiles = await getChangedFiles(repoPath, anchor);
+    if (changedFiles.length === 0) {
+      console.log(JSON.stringify({ status: "no_changes", message: "No changes detected" }));
+      return;
+    }
+
+    const setupConfig = await loadSetupConfig();
+    const config = { ...setupConfig.fileFiltering, ...setupConfig.performance };
+    const gitignore = await loadGitignore(repoPath);
+
+    const { fullContent, includedCount, agentReport } = await generateSnapshotContent(repoPath, changedFiles, anchor, config, gitignore);
+
+    let seqNum = 1;
+    const counterPath = path.join(repoPath, '.eck', 'update_seq');
+    try {
+      const seqData = await fs.readFile(counterPath, 'utf-8');
+      const [savedHash, savedCount] = seqData.split(':');
+      if (savedHash && savedHash.trim() === anchor.substring(0, 7).trim()) {
+        seqNum = parseInt(savedCount || '0') + 1;
+      }
+    } catch (e) {}
+
+    try {
+      await fs.writeFile(counterPath, `${anchor.substring(0, 7)}:${seqNum}`);
+    } catch (e) {}
+
+    const timestamp = generateTimestamp();
+    const shortRepoName = getShortRepoName(path.basename(repoPath));
+    const outputFilename = `eck${shortRepoName}${timestamp}_${anchor.substring(0, 7)}_up${seqNum}.md`;
+    const outputPath = path.join(repoPath, '.eck', 'snapshots', outputFilename);
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, fullContent);
+
+    // --- FEATURE: Active Snapshot (.eck/lastsnapshot/) ---
+    try {
+      const snapDir = path.join(repoPath, '.eck', 'lastsnapshot');
+      await fs.mkdir(snapDir, { recursive: true });
+
+      // 1. Clean up OLD snapshots
+      const existingFiles = await fs.readdir(snapDir);
+      for (const file of existingFiles) {
+        if ((file.startsWith('eck') && file.endsWith('.md')) || file === 'answer.md') {
+          await fs.unlink(path.join(snapDir, file));
+        }
+      }
+
+      // 2. Save new file
+      await fs.writeFile(path.join(snapDir, outputFilename), fullContent);
+    } catch (e) {
+      // Non-critical failure
+    }
+    // --------------------------------------------
+
+    console.log(JSON.stringify({
+      status: "success",
+      snapshot_file: `.eck/snapshots/${outputFilename}`,
+      files_count: includedCount,
+      timestamp: timestamp
+    }));
+
+  } catch (error) {
+    console.log(JSON.stringify({ status: "error", message: error.message }));
+  }
+}

package/src/config.js

@@ -0,0 +1,125 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let cachedConfig = null;
+
+export async function loadSetupConfig() {
+  if (cachedConfig) {
+    return cachedConfig;
+  }
+
+  try {
+    const setupPath = path.join(__dirname, '..', 'setup.json');
+    const setupContent = await fs.readFile(setupPath, 'utf-8');
+    cachedConfig = JSON.parse(setupContent);
+
+    // Basic schema validation for critical fields
+    validateConfigSchema(cachedConfig);
+
+    return cachedConfig;
+  } catch (error) {
+    console.error('Error loading setup.json:', error.message);
+    throw new Error('Failed to load setup.json configuration file');
+  }
+}
+
+/**
+ * Validates critical config fields and warns if missing or invalid
+ */
+function validateConfigSchema(config) {
+  const warnings = [];
+
+  // Validate fileFiltering section
+  if (!config.fileFiltering) {
+    warnings.push('Missing "fileFiltering" section');
+  } else {
+    if (!Array.isArray(config.fileFiltering.filesToIgnore)) {
+      warnings.push('"fileFiltering.filesToIgnore" must be an array');
+    }
+    if (!Array.isArray(config.fileFiltering.dirsToIgnore)) {
+      warnings.push('"fileFiltering.dirsToIgnore" must be an array');
+    }
+  }
+
+  // Validate aiInstructions section
+  if (!config.aiInstructions) {
+    warnings.push('Missing "aiInstructions" section');
+  }
+
+  // Legacy support
+  if (!config.filesToIgnore || !Array.isArray(config.filesToIgnore)) {
+    warnings.push('filesToIgnore missing or not an array - using defaults');
+    config.filesToIgnore = DEFAULT_CONFIG.filesToIgnore;
+  }
+  if (!config.dirsToIgnore || !Array.isArray(config.dirsToIgnore)) {
+    warnings.push('dirsToIgnore missing or not an array - using defaults');
+    config.dirsToIgnore = DEFAULT_CONFIG.dirsToIgnore;
+  }
+
+  if (warnings.length > 0) {
+    console.warn('\n⚠️ Config Validation Warnings:');
+    warnings.forEach(w => console.warn(`   - ${w}`));
+    console.warn('   (Falling back to defaults for missing values where possible)\n');
+  }
+}
+
+/**
+ * Loads and merges all profiles (local-first).
+ */
+export async function getAllProfiles(repoPath) {
+  const globalConfig = await loadSetupConfig();
+  const globalProfiles = globalConfig.contextProfiles || {};
+
+  let localProfiles = {};
+  const localProfilePath = path.join(repoPath, '.eck', 'profiles.json');
+
+  try {
+    const localProfileContent = await fs.readFile(localProfilePath, 'utf-8');
+    localProfiles = JSON.parse(localProfileContent);
+  } catch (e) {
+    // No local profiles.json found, which is fine.
+  }
+
+  // Local profiles override global profiles
+  return { ...globalProfiles, ...localProfiles };
+}
+
+/**
+ * Smart profile loader (Step 2 of dynamic profiles).
+ * Reads local .eck/profiles.json first, then falls back to global setup.json profiles.
+ */
+export async function getProfile(profileName, repoPath) {
+  const globalConfig = await loadSetupConfig();
+  const globalProfiles = globalConfig.contextProfiles || {};
+
+  let localProfiles = {};
+  const localProfilePath = path.join(repoPath, '.eck', 'profiles.json');
+
+  try {
+    const localProfileContent = await fs.readFile(localProfilePath, 'utf-8');
+    localProfiles = JSON.parse(localProfileContent);
+  } catch (e) {
+    // No local profiles.json found, which is fine. We just use globals.
+  }
+
+  // Local profiles override global profiles
+  const allProfiles = { ...globalProfiles, ...localProfiles };
+
+  return allProfiles[profileName] || null;
+}
+
+// Fallback default config for backwards compatibility
+export const DEFAULT_CONFIG = {
+  smartModeTokenThreshold: 200000,
+  filesToIgnore: ['package-lock.json', '*.log', 'yarn.lock'],
+  extensionsToIgnore: ['.sqlite3', '.db', '.DS_Store', '.env', '.pyc'],
+  dirsToIgnore: ['node_modules/', '.git/', 'dist/', 'build/'],
+  maxFileSize: '10MB',
+  maxTotalSize: '100MB',
+  maxDepth: 10,
+  concurrency: 10
+};