@xelth/eck-snapshot 5.9.0 → 6.6.0

package/src/utils/projectDetector.js

@@ -101,6 +101,10 @@ async function calculateTypeScore(projectPath, pattern) {
         if (file === 'package.json') {
           commonSubdirs.push('codex-cli', 'cli', 'client', 'web', 'ui');
         }
+        // Android/Gradle files often live inside android/ subdirectory (polyglot monorepos)
+        if (file.startsWith('build.gradle') || file.startsWith('settings.gradle')) {
+          commonSubdirs.push('android');
+        }
 
         for (const subdir of commonSubdirs) {
           const subdirExists = await fileExists(path.join(projectPath, subdir, file));
@@ -120,8 +124,8 @@ async function calculateTypeScore(projectPath, pattern) {
       if (rootExists) {
         score += 20; // Each required directory adds points
       } else {
-        // Check in common project subdirectories
-        const projectSubdirs = ['codex-rs', 'codex-cli', 'src', 'lib', 'app'];
+        // Check in common project subdirectories (including android/ for polyglot monorepos)
+        const projectSubdirs = ['codex-rs', 'codex-cli', 'src', 'lib', 'app', 'android'];
         for (const projDir of projectSubdirs) {
           const subdirExists = await directoryExists(path.join(projectPath, projDir, dir));
           if (subdirExists) {
@@ -285,9 +289,12 @@ async function getNodejsDetails(projectPath) {
   
   try {
     const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!(await fileExists(packageJsonPath))) {
+      return details;
+    }
     const content = await fs.readFile(packageJsonPath, 'utf-8');
     const packageJson = JSON.parse(content);
-    
+
     details.name = packageJson.name;
     details.version = packageJson.version;
     details.hasTypescript = !!packageJson.devDependencies?.typescript || !!packageJson.dependencies?.typescript;
@@ -393,9 +400,12 @@ async function getReactNativeDetails(projectPath) {
   
   try {
     const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!(await fileExists(packageJsonPath))) {
+      return details;
+    }
     const content = await fs.readFile(packageJsonPath, 'utf-8');
     const packageJson = JSON.parse(content);
-    
+
     details.name = packageJson.name;
     details.version = packageJson.version;
     details.reactNativeVersion = packageJson.dependencies?.['react-native'];
@@ -680,25 +690,60 @@ async function findFileRecursive(basePath, fileName, maxDepth = 3) {
 }
 
 /**
- * Gets project-specific filtering configuration
- * @param {string} projectType - The detected project type
+ * Gets project-specific filtering configuration.
+ * Accepts a single type string OR an array of types (for polyglot monorepos).
+ * When multiple types are provided, filters from ALL types are merged (union).
+ * @param {string|string[]} projectTypes - The detected project type(s)
  * @returns {object} Project-specific filtering rules
  */
-export async function getProjectSpecificFiltering(projectType) {
+export async function getProjectSpecificFiltering(projectTypes) {
   const config = await loadSetupConfig();
-  const projectSpecific = config.fileFiltering?.projectSpecific?.[projectType];
-  
-  if (!projectSpecific) {
-    return {
-      filesToIgnore: [],
-      dirsToIgnore: [],
-      extensionsToIgnore: []
-    };
-  }
-  
-  return {
-    filesToIgnore: projectSpecific.filesToIgnore || [],
-    dirsToIgnore: projectSpecific.dirsToIgnore || [],
-    extensionsToIgnore: projectSpecific.extensionsToIgnore || []
+  const allProjectSpecific = config.fileFiltering?.projectSpecific || {};
+
+  // Normalize to array
+  const types = Array.isArray(projectTypes) ? projectTypes : [projectTypes];
+
+  const merged = {
+    filesToIgnore: [],
+    dirsToIgnore: [],
+    extensionsToIgnore: []
   };
+
+  for (const type of types) {
+    const specific = allProjectSpecific[type];
+    if (specific) {
+      merged.filesToIgnore.push(...(specific.filesToIgnore || []));
+      merged.dirsToIgnore.push(...(specific.dirsToIgnore || []));
+      merged.extensionsToIgnore.push(...(specific.extensionsToIgnore || []));
+    }
+  }
+
+  // Deduplicate
+  merged.filesToIgnore = [...new Set(merged.filesToIgnore)];
+  merged.dirsToIgnore = [...new Set(merged.dirsToIgnore)];
+  merged.extensionsToIgnore = [...new Set(merged.extensionsToIgnore)];
+
+  return merged;
+}
+
+/**
+ * Extracts all detected project types from a detection result.
+ * Returns array of type strings suitable for getProjectSpecificFiltering.
+ * @param {object} detection - Result from detectProjectType()
+ * @returns {string[]} All detected project types
+ */
+export function getAllDetectedTypes(detection) {
+  if (!detection || detection.type === 'unknown') return [];
+
+  const types = [detection.type];
+
+  if (detection.allDetections && detection.allDetections.length > 1) {
+    for (const d of detection.allDetections) {
+      if (!types.includes(d.type)) {
+        types.push(d.type);
+      }
+    }
+  }
+
+  return types;
 }

package/src/utils/tokenEstimator.js

@@ -83,7 +83,7 @@ export async function estimateTokensWithPolynomial(projectType, fileSizeInBytes)
 export function generateTrainingCommand(projectType, estimatedTokens, fileSizeInBytes, projectPath) {
   const projectName = path.basename(projectPath);
   
-  return `eck-snapshot train-tokens ${projectType} ${fileSizeInBytes} ${estimatedTokens} `;
+  return `eck-snapshot '{"name": "eck_train_tokens", "arguments": {"projectType": "${projectType}", "fileSizeBytes": ${fileSizeInBytes}, "estimatedTokens": ${estimatedTokens}, "actualTokens": `;
 }
 
 /**
@@ -140,9 +140,9 @@ export async function addTrainingPoint(projectType, fileSizeInBytes, estimatedTo
 /**
  * Fetch global token weights from Telemetry Hub and merge them into local training data
  */
-export async function syncTokenWeights() {
+export async function syncTokenWeights(silent = false) {
   try {
-    console.log('Fetching global token weights from Telemetry Hub...');
+    if (!silent) console.log('Fetching global token weights from Telemetry Hub...');
     const res = await fetch('https://xelth.com/T/tokens/weights');
     if (!res.ok) throw new Error(res.statusText);
     const data = await res.json();
@@ -152,12 +152,12 @@ export async function syncTokenWeights() {
       // Global coefficients override local ones
       localData.coefficients = { ...localData.coefficients, ...data.coefficients };
       await saveTrainingData(localData);
-      console.log('Global token weights synchronized successfully.');
+      if (!silent) console.log('Global token weights synchronized successfully.');
     } else {
-      console.log('No global weights available yet.');
+      if (!silent) console.log('No global weights available yet.');
     }
   } catch (e) {
-    console.log('Failed to sync token weights: ' + e.message);
+    if (!silent) console.log('Failed to sync token weights: ' + e.message);
   }
 }
 
@@ -233,7 +233,11 @@ export async function showEstimationStats() {
     console.log(`   Training points: ${points.length}`);
     
     if (points.length > 0) {
-      const errors = points.map(p => Math.abs(p.actualTokens - p.estimatedTokens));
+      // Recalculate error against current coefficients, ignoring old stored estimate
+      const errors = points.map(p => {
+        const currentEstimate = evaluatePolynomial(coefficients, p.fileSizeInBytes);
+        return Math.abs(p.actualTokens - currentEstimate);
+      });
       const avgError = errors.reduce((a, b) => a + b, 0) / errors.length;
       console.log(`   Average error: ${Math.round(avgError)} tokens`);
     }

package/src/cli/commands/consilium.js

@@ -1,86 +0,0 @@
-import fs from 'fs/promises';
-
-/**
- * Generate a consilium request for complex decisions
- */
-async function generateConsiliumRequest(task, complexity, agentId) {
-  const request = {
-    consilium_request: {
-      request_id: `cons-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      timestamp: new Date().toISOString(),
-      requesting_agent: agentId,
-      complexity_score: complexity,
-      
-      task: {
-        type: task.type || "technical_decision",
-        title: task.title,
-        description: task.description,
-        current_implementation: task.currentCode || "N/A",
-        proposed_solution: task.proposedSolution || "To be determined",
-        constraints: task.constraints || [],
-        success_criteria: task.criteria || []
-      },
-      
-      consilium_instructions: `
-        You are a technical expert participating in a consilium decision.
-        
-        RESPOND WITH:
-        1. Your expert opinion on the best approach
-        2. Specific technical recommendations
-        3. Potential risks and mitigation strategies
-        4. Your confidence level (0-100%)
-        
-        FORMAT YOUR RESPONSE AS JSON:
-        {
-          "expert": "[Your Model Name]",
-          "role": "[Your assigned role]",
-          "recommendation": {
-            "approach": "Detailed technical solution",
-            "implementation_steps": ["step1", "step2"],
-            "key_benefits": ["benefit1", "benefit2"],
-            "risks": ["risk1", "risk2"],
-            "mitigation": ["strategy1", "strategy2"]
-          },
-          "alternatives_considered": ["alt1", "alt2"],
-          "confidence": 85,
-          "critical_warnings": []
-        }
-      `,
-      
-      aggregation_rules: {
-        minimum_confidence_required: 60,
-        consensus_threshold: 0.66,
-        veto_roles: ["security_auditor"],
-        conflict_resolution: "weighted_average_with_discussion"
-      }
-    }
-  };
-  
-  return request;
-}
-
-export async function generateConsilium(options) {
-  console.log('🧠 Generating Consilium Request...');
-  
-  const task = {
-    type: options.type || 'technical_decision',
-    title: options.title || 'Technical Decision Required',
-    description: options.description || 'Please provide a description',
-    constraints: options.constraints ? options.constraints.split(',') : [],
-    currentCode: options.snapshot || null
-  };
-  
-  const complexity = options.complexity || 7;
-  const agentId = options.agent || 'AGENT_ORCHESTRATOR';
-  
-  const request = await generateConsiliumRequest(task, complexity, agentId);
-  
-  const outputFile = options.output || 'consilium_request.json';
-  await fs.writeFile(outputFile, JSON.stringify(request, null, 2));
-  
-  console.log(`✅ Consilium request saved to: ${outputFile}`);
-  console.log('\n📋 Next steps:');
-  console.log('1. Send this request to multiple LLM experts');
-  console.log('2. Collect their responses');
-  console.log('3. Run: eck-snapshot process-consilium <responses.json>');
-}

package/src/cli/commands/detectProfiles.js

@@ -1,98 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import ora from 'ora';
-import { executePrompt as askClaude } from '../../services/claudeCliService.js';
-import { scanDirectoryRecursively, generateDirectoryTree, initializeEckManifest, loadConfig } from '../../utils/fileUtils.js';
-import { loadSetupConfig } from '../../config.js';
-
-/**
- * Extracts a JSON object from a string that might contain markdown wrappers or log output.
- * Finds the first opening brace '{' and the last closing brace '}' to extract the JSON.
- */
-function extractJson(text) {
-  const match = text.match(/```(json)?([\s\S]*?)```/);
-  if (match && match[2]) {
-    return match[2].trim();
-  }
-
-  const firstBrace = text.indexOf('{');
-  const lastBrace = text.lastIndexOf('}');
-
-  if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
-    return text.substring(firstBrace, lastBrace + 1).trim();
-  }
-
-  return text.trim();
-}
-
-/**
- * Scans the project structure, saves the directory tree to a file, and asks an AI to generate
- * context profiles, saving them to .eck/profiles.json.
- */
-export async function detectProfiles(repoPath, options) {
-  const spinner = ora('Initializing and scanning project structure...').start();
-  try {
-    await initializeEckManifest(repoPath);
-
-    const setupConfig = await loadSetupConfig();
-    const userConfig = await loadConfig(options.config);
-    const config = {
-        ...userConfig,
-        ...setupConfig.fileFiltering,
-        ...setupConfig.performance
-    };
-
-    const allFiles = await scanDirectoryRecursively(repoPath, config, repoPath);
-    spinner.text = 'Generating directory tree...';
-    const dirTree = await generateDirectoryTree(repoPath, '', allFiles, 0, config.maxDepth, config);
-
-    if (!dirTree) {
-        throw new Error('Failed to generate directory tree or project is empty.');
-    }
-
-    spinner.text = 'Saving directory tree to file...';
-    const treeFilePath = path.join(repoPath, '.eck', 'directory_tree_for_profiling.md');
-    await fs.writeFile(treeFilePath, dirTree);
-
-    const prompt = `You are a code architect. Based on the file directory tree found in the file at './.eck/directory_tree_for_profiling.md', please identify logical 'context profiles' for splitting the project.
-Your output MUST be ONLY a valid JSON object.
-The keys of the object MUST be the profile names (e.g., 'frontend', 'backend', 'core-logic', 'docs').
-The values MUST be an object containing 'include' and 'exclude' arrays of glob patterns.
-Example: {"frontend": {"include": ["packages/ui/**"], "exclude": []}, "docs": {"include": ["docs/**"], "exclude": []}}.
-DO NOT add any conversational text, introductory sentences, or explanations. Your entire response must be ONLY the JSON object.`;
-
-    spinner.text = 'Asking AI to analyze directory tree and detect profiles...';
-    const aiResponseObject = await askClaude(prompt, { taskSize: allFiles.length });
-    const rawText = aiResponseObject.result;
-
-    if (!rawText || typeof rawText.replace !== 'function') {
-      throw new Error(`AI returned invalid content type: ${typeof rawText}`);
-    }
-
-    spinner.text = 'Saving generated profiles...';
-    const cleanedJson = extractJson(rawText);
-    let parsedProfiles;
-    try {
-        parsedProfiles = JSON.parse(cleanedJson);
-    } catch (e) {
-        console.error('\nInvalid JSON received from AI:', cleanedJson);
-        throw new Error(`AI returned invalid JSON: ${e.message}`);
-    }
-
-    const outputPath = path.join(repoPath, '.eck', 'profiles.json');
-    await fs.writeFile(outputPath, JSON.stringify(parsedProfiles, null, 2));
-
-    const profileKeys = Object.keys(parsedProfiles);
-    spinner.succeed(`Successfully detected and saved ${profileKeys.length} profiles to ${outputPath}`);
-
-    console.log('\n✨ Detected Profiles:');
-    console.log('---------------------------');
-    for (const profileName of profileKeys) {
-        console.log(`  - ${profileName}`);
-    }
-    console.log('\nYou can now use these profile names with the --profile flag.');
-
-  } catch (error) {
-    spinner.fail(`Failed to detect profiles: ${error.message}`);
-  }
-}

package/src/cli/commands/envSync.js

@@ -1,319 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import crypto from 'crypto';
-import zlib from 'zlib';
-import { promisify } from 'util';
-import chalk from 'chalk';
-import ora from 'ora';
-import inquirer from 'inquirer';
-
-const gzip = promisify(zlib.gzip);
-const gunzip = promisify(zlib.gunzip);
-
-const SYNC_FILENAME = '.eck-sync.enc';
-const ECK_DIR = '.eck';
-
-// Files to include (relative to .eck/). Snapshots excluded intentionally.
-const INCLUDE_FILES = [
-  'anchor',
-  'claude-mcp-config.json',
-  'CONTEXT.md',
-  'ENVIRONMENT.md',
-  'JOURNAL.md',
-  'OPERATIONS.md',
-  'ROADMAP.md',
-  'TECH_DEBT.md',
-  'update_seq',
-];
-
-// Crypto constants
-const PBKDF2_ITERATIONS = 100_000;
-const PBKDF2_DIGEST = 'sha512';
-const KEY_LENGTH = 32;
-const SALT_LENGTH = 16;
-const IV_LENGTH = 12;
-const AUTH_TAG_LENGTH = 16;
-const ALGORITHM = 'aes-256-gcm';
-const FORMAT_VERSION = 1;
-
-// ── Password ────────────────────────────────────────────────────────
-
-async function getPassword(action = 'encrypt') {
-  const envKey = process.env.ECK_SYNC_KEY;
-  if (envKey) {
-    if (envKey.length < 4) throw new Error('ECK_SYNC_KEY must be at least 4 characters');
-    return envKey;
-  }
-
-  const verb = action === 'encrypt' ? 'encrypt' : 'decrypt';
-  const { password } = await inquirer.prompt([{
-    type: 'password',
-    name: 'password',
-    message: `Enter password to ${verb} .eck/ environment:`,
-    mask: '*',
-    validate: (input) => input.length >= 4 || 'Password must be at least 4 characters',
-  }]);
-
-  if (action === 'encrypt') {
-    const { confirm } = await inquirer.prompt([{
-      type: 'password',
-      name: 'confirm',
-      message: 'Confirm password:',
-      mask: '*',
-    }]);
-    if (password !== confirm) throw new Error('Passwords do not match');
-  }
-
-  return password;
-}
-
-// ── Encryption ──────────────────────────────────────────────────────
-
-function encrypt(plainBuffer, password) {
-  const salt = crypto.randomBytes(SALT_LENGTH);
-  const key = crypto.pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LENGTH, PBKDF2_DIGEST);
-  const iv = crypto.randomBytes(IV_LENGTH);
-
-  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
-  const encrypted = Buffer.concat([cipher.update(plainBuffer), cipher.final()]);
-  const authTag = cipher.getAuthTag();
-
-  // Binary: salt(16) + iv(12) + authTag(16) + ciphertext
-  return Buffer.concat([salt, iv, authTag, encrypted]);
-}
-
-function decrypt(encBuffer, password) {
-  const minSize = SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH + 1;
-  if (encBuffer.length < minSize) {
-    throw new Error('Encrypted file is too small or corrupted');
-  }
-
-  let offset = 0;
-  const salt = encBuffer.subarray(offset, offset += SALT_LENGTH);
-  const iv = encBuffer.subarray(offset, offset += IV_LENGTH);
-  const authTag = encBuffer.subarray(offset, offset += AUTH_TAG_LENGTH);
-  const ciphertext = encBuffer.subarray(offset);
-
-  const key = crypto.pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LENGTH, PBKDF2_DIGEST);
-  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
-  decipher.setAuthTag(authTag);
-
-  try {
-    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-  } catch {
-    throw new Error('Decryption failed. Wrong password or corrupted file.');
-  }
-}
-
-// ── Path templating ─────────────────────────────────────────────────
-
-function templatizePaths(content, projectRoot, homeDir, filename) {
-  let result = content;
-
-  if (filename.endsWith('.json')) {
-    // JSON files store backslashes escaped: C:\\Users\\...
-    const projEsc = projectRoot.replace(/\\/g, '\\\\');
-    const homeEsc = homeDir.replace(/\\/g, '\\\\');
-    result = result.replaceAll(projEsc, '{{PROJECT_ROOT}}');
-    result = result.replaceAll(homeEsc, '{{HOME}}');
-  }
-
-  // Forward-slash and raw variants
-  const projFwd = projectRoot.replace(/\\/g, '/');
-  const homeFwd = homeDir.replace(/\\/g, '/');
-  result = result.replaceAll(projectRoot, '{{PROJECT_ROOT}}');
-  result = result.replaceAll(projFwd, '{{PROJECT_ROOT}}');
-  result = result.replaceAll(homeDir, '{{HOME}}');
-  result = result.replaceAll(homeFwd, '{{HOME}}');
-
-  return result;
-}
-
-function resolveTemplates(content, projectRoot, homeDir, filename) {
-  let result = content;
-
-  if (filename.endsWith('.json')) {
-    // JSON needs escaped backslashes on Windows
-    const projEsc = projectRoot.replace(/\\/g, '\\\\');
-    const homeEsc = homeDir.replace(/\\/g, '\\\\');
-    result = result.replaceAll('{{PROJECT_ROOT}}', projEsc);
-    result = result.replaceAll('{{HOME}}', homeEsc);
-  } else {
-    result = result.replaceAll('{{PROJECT_ROOT}}', projectRoot);
-    result = result.replaceAll('{{HOME}}', homeDir);
-  }
-
-  return result;
-}
-
-// ── Push ─────────────────────────────────────────────────────────────
-
-export async function envPush(options = {}) {
-  const projectRoot = process.cwd();
-  const eckDir = path.join(projectRoot, ECK_DIR);
-  const outputPath = path.join(projectRoot, SYNC_FILENAME);
-  const homeDir = os.homedir();
-  const spinner = ora();
-
-  try {
-    // Verify .eck/ exists
-    spinner.start('Checking .eck/ directory...');
-    try {
-      await fs.access(eckDir);
-    } catch {
-      spinner.fail('.eck/ directory not found');
-      console.log(chalk.yellow('Run eck-snapshot first to create .eck/ context files.'));
-      process.exit(1);
-    }
-    spinner.succeed('.eck/ directory found');
-
-    // Read included files
-    spinner.start('Reading .eck/ files...');
-    const payload = {
-      version: FORMAT_VERSION,
-      timestamp: new Date().toISOString(),
-      files: {},
-    };
-
-    let fileCount = 0;
-    for (const filename of INCLUDE_FILES) {
-      const filePath = path.join(eckDir, filename);
-      try {
-        const content = await fs.readFile(filePath, 'utf-8');
-        const templated = templatizePaths(content, projectRoot, homeDir, filename);
-        payload.files[filename] = { content: templated, encoding: 'utf8' };
-        fileCount++;
-        if (options.verbose) {
-          console.log(chalk.gray(`  + ${filename} (${Buffer.byteLength(content)} bytes)`));
-        }
-      } catch {
-        if (options.verbose) {
-          console.log(chalk.gray(`  - ${filename} (not found, skipping)`));
-        }
-      }
-    }
-
-    if (fileCount === 0) {
-      spinner.fail('No .eck/ files found to pack');
-      process.exit(1);
-    }
-    spinner.succeed(`Read ${fileCount} files from .eck/`);
-
-    // Compress
-    spinner.start('Compressing...');
-    const jsonStr = JSON.stringify(payload, null, 2);
-    const compressed = await gzip(Buffer.from(jsonStr, 'utf-8'));
-    spinner.succeed(`Compressed: ${Buffer.byteLength(jsonStr)} -> ${compressed.length} bytes`);
-
-    // Encrypt
-    const password = await getPassword('encrypt');
-    spinner.start('Encrypting...');
-    const encrypted = encrypt(compressed, password);
-    spinner.succeed(`Encrypted: ${encrypted.length} bytes`);
-
-    // Write
-    await fs.writeFile(outputPath, encrypted);
-
-    console.log(chalk.green.bold('\nEnvironment pushed successfully!'));
-    console.log(chalk.gray(`  Files packed: ${fileCount}`));
-    console.log(chalk.gray(`  Output size:  ${encrypted.length} bytes`));
-    console.log(chalk.gray(`  Output file:  ${SYNC_FILENAME}`));
-    console.log(chalk.yellow('\nCommit .eck-sync.enc to git to share across machines.'));
-
-  } catch (error) {
-    spinner.fail(`Push failed: ${error.message}`);
-    if (options.verbose) console.error(error.stack);
-    process.exit(1);
-  }
-}
-
-// ── Pull ─────────────────────────────────────────────────────────────
-
-export async function envPull(options = {}) {
-  const projectRoot = process.cwd();
-  const eckDir = path.join(projectRoot, ECK_DIR);
-  const inputPath = path.join(projectRoot, SYNC_FILENAME);
-  const homeDir = os.homedir();
-  const spinner = ora();
-
-  try {
-    // Verify .eck-sync.enc exists
-    spinner.start(`Checking ${SYNC_FILENAME}...`);
-    try {
-      await fs.access(inputPath);
-    } catch {
-      spinner.fail(`${SYNC_FILENAME} not found in project root`);
-      console.log(chalk.yellow('Run "eck-snapshot env push" first, or pull the file from git.'));
-      process.exit(1);
-    }
-    spinner.succeed(`${SYNC_FILENAME} found`);
-
-    // Conflict check
-    if (!options.force) {
-      try {
-        await fs.access(eckDir);
-        const { action } = await inquirer.prompt([{
-          type: 'list',
-          name: 'action',
-          message: '.eck/ directory already exists. What would you like to do?',
-          choices: [
-            { name: 'Overwrite existing files', value: 'overwrite' },
-            { name: 'Cancel', value: 'cancel' },
-          ],
-        }]);
-        if (action === 'cancel') {
-          console.log(chalk.yellow('Pull cancelled.'));
-          return;
-        }
-      } catch {
-        // .eck/ doesn't exist, proceed
-      }
-    }
-
-    // Read + decrypt
-    spinner.start('Reading encrypted file...');
-    const encrypted = await fs.readFile(inputPath);
-    spinner.succeed(`Read ${encrypted.length} bytes`);
-
-    const password = await getPassword('decrypt');
-    spinner.start('Decrypting...');
-    const compressed = decrypt(encrypted, password);
-    spinner.succeed('Decrypted');
-
-    // Decompress + parse
-    spinner.start('Decompressing...');
-    const jsonBuffer = await gunzip(compressed);
-    const payload = JSON.parse(jsonBuffer.toString('utf-8'));
-    spinner.succeed('Decompressed');
-
-    if (payload.version !== FORMAT_VERSION) {
-      throw new Error(`Unsupported format version: ${payload.version} (expected ${FORMAT_VERSION})`);
-    }
-
-    // Restore files
-    await fs.mkdir(eckDir, { recursive: true });
-
-    const fileNames = Object.keys(payload.files);
-    spinner.start(`Restoring ${fileNames.length} files...`);
-
-    for (const filename of fileNames) {
-      const { content } = payload.files[filename];
-      const resolved = resolveTemplates(content, projectRoot, homeDir, filename);
-      await fs.writeFile(path.join(eckDir, filename), resolved, 'utf-8');
-      if (options.verbose) {
-        console.log(chalk.gray(`  + ${filename}`));
-      }
-    }
-    spinner.succeed(`Restored ${fileNames.length} files to .eck/`);
-
-    console.log(chalk.green.bold('\nEnvironment pulled successfully!'));
-    console.log(chalk.gray(`  Files restored: ${fileNames.length}`));
-    console.log(chalk.gray(`  Packed at:      ${payload.timestamp}`));
-
-  } catch (error) {
-    spinner.fail(`Pull failed: ${error.message}`);
-    if (options.verbose) console.error(error.stack);
-    process.exit(1);
-  }
-}