@xelth/eck-snapshot 2.2.0 → 4.0.0

package/src/cli/commands/detectProject.js

@@ -0,0 +1,112 @@
+import { detectProjectType, getProjectSpecificFiltering } from '../../utils/projectDetector.js';
+import { displayProjectInfo } from '../../utils/fileUtils.js';
+import chalk from 'chalk';
+
+/**
+ * Command to detect and display project information
+ * @param {string} projectPath - Path to the project
+ * @param {object} options - Command options
+ */
+export async function detectProject(projectPath = '.', options = {}) {
+  console.log(chalk.blue('🔍 Detecting project type...\n'));
+  
+  try {
+    // Detect project type
+    const detection = await detectProjectType(projectPath);
+    displayProjectInfo(detection);
+    
+    // Show filtering rules that would be applied
+    if (detection.type !== 'unknown') {
+      const filtering = await getProjectSpecificFiltering(detection.type);
+      
+      if (filtering.filesToIgnore.length > 0 || 
+          filtering.dirsToIgnore.length > 0 || 
+          filtering.extensionsToIgnore.length > 0) {
+        console.log(chalk.yellow('📋 Project-specific filtering rules:'));
+        
+        if (filtering.filesToIgnore.length > 0) {
+          console.log(`   Files to ignore: ${filtering.filesToIgnore.join(', ')}`);
+        }
+        
+        if (filtering.dirsToIgnore.length > 0) {
+          console.log(`   Directories to ignore: ${filtering.dirsToIgnore.join(', ')}`);
+        }
+        
+        if (filtering.extensionsToIgnore.length > 0) {
+          console.log(`   Extensions to ignore: ${filtering.extensionsToIgnore.join(', ')}`);
+        }
+        
+        console.log('');
+      }
+    }
+    
+    // Show Android parsing info if it's an Android project
+    if (detection.type === 'android') {
+      console.log(chalk.green('🤖 Android parsing supported via unified segmenter'));
+      console.log('');
+    }
+    
+    // Show verbose details if requested
+    if (options.verbose && detection.allDetections) {
+      console.log(chalk.blue('📊 All detection results:'));
+      for (const result of detection.allDetections) {
+        console.log(`   ${result.type}: score ${result.score}, priority ${result.priority}`);
+      }
+      console.log('');
+    }
+    
+    // Provide suggestions
+    console.log(chalk.blue('💡 Suggested commands:'));
+
+    if (detection.type === 'android') {
+      console.log('   eck-snapshot snapshot --profile android-core    # Core Android files');
+      console.log('   eck-snapshot snapshot --profile android-config  # Build configuration');
+    } else if (detection.type === 'nodejs') {
+      console.log('   eck-snapshot snapshot --profile backend         # Backend code');
+      console.log('   eck-snapshot snapshot --profile frontend        # Frontend code');
+    } else {
+      console.log('   eck-snapshot snapshot                           # Full project snapshot');
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error detecting project:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Command to test file parsing using the unified segmenter
+ * @param {string} filePath - Path to the file to test
+ * @param {object} options - Command options
+ */
+export async function testFileParsing(filePath, options = {}) {
+  console.log(chalk.blue(`🧪 Testing file parsing: ${filePath}\n`));
+  
+  try {
+    const { segmentFile } = await import('../../core/segmenter.js');
+    const fs = await import('fs/promises');
+    
+    // Read file content
+    const content = await fs.readFile(filePath, 'utf-8');
+    console.log(chalk.blue(`📄 File size: ${content.length} characters`));
+    
+    // Parse file using unified segmenter
+    const chunks = await segmentFile(filePath);
+    
+    console.log(chalk.green(`\n🎯 Extracted ${chunks.length} chunks:`));
+    
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      console.log(`\n${i + 1}. ${chalk.yellow(chunk.chunk_name)} (${chunk.chunk_type})`);
+      
+      if (options.showContent) {
+        const preview = chunk.code.substring(0, 200);
+        console.log(chalk.gray(`   Content preview: ${preview}${chunk.code.length > 200 ? '...' : ''}`));
+      }
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error parsing file:'), error.message);
+    process.exit(1);
+  }
+}

package/src/cli/commands/generateProfileGuide.js

@@ -0,0 +1,91 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ora from 'ora';
+import { loadSetupConfig } from '../../config.js';
+import { scanDirectoryRecursively, generateDirectoryTree, initializeEckManifest, loadConfig } from '../../utils/fileUtils.js';
+
+function buildPrompt(projectPath) {
+  const normalizedPath = path.resolve(projectPath);
+  return `You are a code architect helping a developer curate manual context profiles for a repository.
+Project root: ${normalizedPath}
+
+Use the project directory tree provided separately to identify logical groupings of files that should travel together during focused work.
+
+Instructions:
+1. Propose profile names that reflect the responsibilities or layers of the codebase.
+2. For each profile, produce an object with "include" and "exclude" arrays of glob patterns (minimize overlap, prefer directory-level globs).
+3. Always include a sensible catch-all profile (for example, "default") if one is not obvious.
+4. Call out generated assets, tests, or vendor files in "exclude" arrays when appropriate.
+5. Return **only** valid JSON. Do not wrap the response in markdown fences or add commentary.
+`;
+}
+
+function buildGuideContent({ prompt, directoryTree }) {
+  const timestamp = new Date().toISOString();
+  const trimmedTree = directoryTree.trimEnd();
+
+  return [
+    '# Profile Generation Guide',
+    '',
+    `Generated: ${timestamp}`,
+    '',
+    '## How to Use',
+    '- Copy the prompt below into your AI assistant or follow it yourself.',
+    '- When using an AI, paste the directory tree afterward so it has full project context.',
+    "- Review the suggested profiles, then save the JSON to `.eck/profiles.json` when you are satisfied.",
+    '',
+    '## Recommended Prompt',
+    '```text',
+    prompt.trimEnd(),
+    '```',
+    '',
+    '## Project Directory Tree',
+    '```text',
+    trimmedTree,
+    '```',
+    ''
+  ].join('\n');
+}
+
+export async function generateProfileGuide(repoPath = process.cwd(), options = {}) {
+  const spinner = ora('Preparing profile generation guide...').start();
+  const projectPath = path.resolve(repoPath);
+
+  try {
+    spinner.text = 'Ensuring .eck manifest directory is initialized...';
+    await initializeEckManifest(projectPath);
+
+    spinner.text = 'Loading configuration...';
+    const setupConfig = await loadSetupConfig();
+    const userConfig = await loadConfig(options.config);
+    const combinedConfig = {
+      ...userConfig,
+      ...(setupConfig.fileFiltering || {}),
+      ...(setupConfig.performance || {})
+    };
+
+    spinner.text = 'Scanning repository files...';
+    const allFiles = await scanDirectoryRecursively(projectPath, combinedConfig, projectPath);
+
+    spinner.text = 'Building directory tree...';
+    const maxDepth = Number(combinedConfig.maxDepth ?? 10);
+    const directoryTree = await generateDirectoryTree(projectPath, '', allFiles, 0, Number.isFinite(maxDepth) ? maxDepth : 10, combinedConfig);
+
+    if (!directoryTree) {
+      throw new Error('Failed to generate directory tree or project is empty.');
+    }
+
+    const prompt = buildPrompt(projectPath);
+    const guideContent = buildGuideContent({ prompt, directoryTree });
+    const guidePath = path.join(projectPath, '.eck', 'profile_generation_guide.md');
+
+    await fs.mkdir(path.dirname(guidePath), { recursive: true });
+    spinner.text = 'Writing guide to .eck/profile_generation_guide.md...';
+    await fs.writeFile(guidePath, guideContent, 'utf-8');
+
+    spinner.succeed(`Profile generation guide saved to ${guidePath}`);
+  } catch (error) {
+    spinner.fail(`Failed to generate profile guide: ${error.message}`);
+    throw error;
+  }
+}

package/src/cli/commands/pruneSnapshot.js

@@ -0,0 +1,106 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ora from 'ora';
+import { executePrompt as askClaude } from '../../services/claudeCliService.js';
+import { parseSnapshotContent, parseSize, formatSize } from '../../utils/fileUtils.js';
+
+function extractJson(text) {
+  const match = text.match(/```(json)?([\s\S]*?)```/);
+  if (match && match[2]) {
+    return match[2].trim();
+  }
+  const firstBracket = text.indexOf('[');
+  const lastBracket = text.lastIndexOf(']');
+  if (firstBracket !== -1 && lastBracket !== -1 && lastBracket > firstBracket) {
+    return text.substring(firstBracket, lastBracket + 1).trim();
+  }
+  return text.trim();
+}
+
+export async function pruneSnapshot(snapshotFile, options) {
+  const spinner = ora('Starting snapshot pruning process...').start();
+  try {
+    const targetSize = parseSize(options.targetSize);
+    spinner.text = `Reading snapshot file: ${snapshotFile}`;
+    const snapshotContent = await fs.readFile(snapshotFile, 'utf-8');
+    const snapshotHeader = snapshotContent.split('--- File: /')[0];
+    const files = parseSnapshotContent(snapshotContent);
+
+    if (files.length === 0) {
+      spinner.warn('No files found in the snapshot.');
+      return;
+    }
+
+    const currentSize = Buffer.byteLength(snapshotContent, 'utf-8');
+    if (currentSize <= targetSize) {
+      spinner.succeed(`Snapshot is already smaller than the target size. (${formatSize(currentSize)} < ${formatSize(targetSize)})`);
+      return;
+    }
+
+    spinner.text = 'Asking AI to rank files by importance...';
+    const filePaths = files.map(f => f.path);
+
+    const prompt = `Return a JSON array ranking these file paths by importance (most important first).
+
+Important files: package.json, index.js, main entry points, core logic, configuration
+Less important: tests, documentation, examples
+
+Files to rank:
+${filePaths.join('\n')}
+
+Return format (NOTHING else, no markdown, no explanations, ONLY the array):
+["file1", "file2", "file3"]`;
+
+    const aiResponseObject = await askClaude(prompt);
+    const rawText = aiResponseObject.response || aiResponseObject.response_text || aiResponseObject.result;
+    const cleanedJson = extractJson(rawText);
+
+    let rankedFiles;
+    try {
+      rankedFiles = JSON.parse(cleanedJson);
+      if (!Array.isArray(rankedFiles) || rankedFiles.some(item => typeof item !== 'string')) {
+        throw new Error('AI response is not an array of strings.');
+      }
+    } catch (e) {
+      spinner.fail(`Failed to parse AI's file ranking: ${e.message}`);
+      console.error('Received from AI:', cleanedJson);
+      return;
+    }
+
+    spinner.text = 'Building pruned snapshot...';
+    const fileMap = new Map(files.map(f => [f.path, f.content]));
+    let newSnapshotContent = snapshotHeader;
+    let newSize = Buffer.byteLength(newSnapshotContent, 'utf-8');
+    let filesIncluded = 0;
+
+    for (const filePath of rankedFiles) {
+      if (fileMap.has(filePath)) {
+        const fileContent = fileMap.get(filePath);
+        const fileEntry = `--- File: /${filePath} ---\n\n${fileContent}\n\n`;
+        const entrySize = Buffer.byteLength(fileEntry, 'utf-8');
+
+        if (newSize + entrySize > targetSize) {
+          break;
+        }
+
+        newSnapshotContent += fileEntry;
+        newSize += entrySize;
+        filesIncluded++;
+      }
+    }
+
+    const outputFilename = `${path.basename(snapshotFile, path.extname(snapshotFile))}_pruned_${options.targetSize}${path.extname(snapshotFile)}`;
+    const outputPath = path.join(path.dirname(snapshotFile), outputFilename);
+
+    await fs.writeFile(outputPath, newSnapshotContent);
+
+    spinner.succeed('Snapshot pruning complete!');
+    console.log(`- Original Size: ${formatSize(currentSize)}`);
+    console.log(`- New Size: ${formatSize(newSize)}`);
+    console.log(`- Files Included: ${filesIncluded} / ${files.length}`);
+    console.log(`- Pruned snapshot saved to: ${outputPath}`);
+
+  } catch (error) {
+    spinner.fail(`An error occurred during pruning: ${error.message}`);
+  }
+}

package/src/cli/commands/restoreSnapshot.js

@@ -0,0 +1,173 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { SingleBar, Presets } from 'cli-progress';
+import pLimit from 'p-limit';
+import zlib from 'zlib';
+import { promisify } from 'util';
+import inquirer from 'inquirer';
+
+import { parseSnapshotContent, filterFilesToRestore, validateFilePaths } from '../../utils/fileUtils.js';
+
+const gunzip = promisify(zlib.gunzip);
+
+export async function restoreSnapshot(snapshotFile, targetDir, options) {
+  const absoluteSnapshotPath = path.resolve(snapshotFile);
+  const absoluteTargetDir = path.resolve(targetDir);
+  
+  console.log(`📄 Starting restore from snapshot: ${absoluteSnapshotPath}`);
+  console.log(`📁 Target directory: ${absoluteTargetDir}`);
+
+  try {
+    let rawContent;
+    
+    if (snapshotFile.endsWith('.gz')) {
+      const compressedBuffer = await fs.readFile(absoluteSnapshotPath);
+      rawContent = (await gunzip(compressedBuffer)).toString('utf-8');
+      console.log('✅ Decompressed gzipped snapshot');
+    } else {
+      rawContent = await fs.readFile(absoluteSnapshotPath, 'utf-8');
+    }
+
+    let filesToRestore;
+    
+    try {
+      const jsonData = JSON.parse(rawContent);
+      if (jsonData.content) {
+        console.log('📄 Detected JSON format, extracting content');
+        filesToRestore = parseSnapshotContent(jsonData.content);
+      } else {
+        throw new Error('JSON format detected, but no "content" key found');
+      }
+    } catch (e) {
+      console.log('📄 Treating snapshot as plain text format');
+      filesToRestore = parseSnapshotContent(rawContent);
+    }
+    
+    if (filesToRestore.length === 0) {
+      console.warn('⚠️ No files found to restore in the snapshot');
+      return;
+    }
+
+    if (options.include || options.exclude) {
+      filesToRestore = filterFilesToRestore(filesToRestore, options);
+      if (filesToRestore.length === 0) {
+        console.warn('⚠️ No files remaining after applying filters');
+        return;
+      }
+    }
+
+    const invalidFiles = validateFilePaths(filesToRestore, absoluteTargetDir);
+    if (invalidFiles.length > 0) {
+      console.error('❌ Invalid file paths detected (potential directory traversal):');
+      invalidFiles.forEach(file => console.error(`  ${file}`));
+      process.exit(1);
+    }
+
+    console.log(`📊 Found ${filesToRestore.length} files to restore`);
+    
+    if (options.dryRun) {
+      console.log('\n🔍 Dry run mode - files that would be restored:');
+      filesToRestore.forEach(file => {
+        const fullPath = path.join(absoluteTargetDir, file.path);
+        console.log(`  ${fullPath}`);
+      });
+      return;
+    }
+
+    if (!options.force) {
+      const { confirm } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: `You are about to write ${filesToRestore.length} files to ${absoluteTargetDir}. Existing files will be overwritten. Continue?`,
+        default: false
+      }]);
+      
+      if (!confirm) {
+        console.log('🚫 Restore operation cancelled by user');
+        return;
+      }
+    }
+
+    await fs.mkdir(absoluteTargetDir, { recursive: true });
+    
+    const stats = {
+      totalFiles: filesToRestore.length,
+      restoredFiles: 0,
+      failedFiles: 0,
+      errors: []
+    };
+    
+    const progressBar = options.verbose ? null : new SingleBar({
+      format: 'Restoring |{bar}| {percentage}% | {value}/{total} files',
+      barCompleteChar: '\u2588',
+      barIncompleteChar: '\u2591',
+      hideCursor: true
+    }, Presets.shades_classic);
+    
+    if (progressBar) progressBar.start(filesToRestore.length, 0);
+
+    const limit = pLimit(options.concurrency || 10);
+    const filePromises = filesToRestore.map((file, index) => 
+      limit(async () => {
+        try {
+          const fullPath = path.join(absoluteTargetDir, file.path);
+          const dir = path.dirname(fullPath);
+
+          await fs.mkdir(dir, { recursive: true });
+          await fs.writeFile(fullPath, file.content, 'utf-8');
+          
+          stats.restoredFiles++;
+          
+          if (progressBar) {
+            progressBar.update(index + 1);
+          } else if (options.verbose) {
+            console.log(`✅ Restored: ${file.path}`);
+          }
+          
+          return { success: true, file: file.path };
+        } catch (error) {
+          stats.failedFiles++;
+          stats.errors.push({ file: file.path, error: error.message });
+          
+          if (options.verbose) {
+            console.log(`❌ Failed to restore: ${file.path} - ${error.message}`);
+          }
+          
+          return { success: false, file: file.path, error: error.message };
+        }
+      })
+    );
+
+    await Promise.allSettled(filePromises);
+    if (progressBar) progressBar.stop();
+
+    console.log('\n📊 Restore Summary');
+    console.log('='.repeat(50));
+    console.log(`🎉 Restore completed!`);
+    console.log(`✅ Successfully restored: ${stats.restoredFiles} files`);
+    
+    if (stats.failedFiles > 0) {
+      console.log(`❌ Failed to restore: ${stats.failedFiles} files`);
+      if (stats.errors.length > 0) {
+        console.log('\n⚠️ Errors encountered:');
+        stats.errors.slice(0, 5).forEach(({ file, error }) => {
+          console.log(`  ${file}: ${error}`);
+        });
+        if (stats.errors.length > 5) {
+          console.log(`  ... and ${stats.errors.length - 5} more errors`);
+        }
+      }
+    }
+    
+    console.log(`📁 Target directory: ${absoluteTargetDir}`);
+    console.log('='.repeat(50));
+    
+  } catch (error) {
+    console.error('\n❌ An error occurred during restore:');
+    console.error(error.message);
+    if (options.verbose) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}

package/src/cli/commands/setupGemini.js

@@ -0,0 +1,149 @@
+import which from 'which';
+import path from 'path';
+import fs from 'fs/promises';
+import os from 'os';
+import chalk from 'chalk';
+
+/**
+ * Sets up claude.toml configuration for gemini-cli integration with dynamic paths
+ * @param {Object} options - Command options
+ */
+export async function setupGemini(options = {}) {
+  try {
+    console.log(chalk.blue('🔧 Setting up gemini-cli integration with dynamic paths...'));
+
+    // Check if gemini-cli is installed
+    let geminiCliPath;
+    try {
+      geminiCliPath = await which('gemini-cli');
+      console.log(chalk.green(`✅ Found gemini-cli at: ${geminiCliPath}`));
+    } catch (error) {
+      console.error(chalk.red('❌ gemini-cli not found in PATH'));
+      console.log(chalk.yellow('💡 Please install gemini-cli first:'));
+      console.log(chalk.cyan('   npm install -g gemini-cli'));
+      process.exit(1);
+    }
+
+    // Get current working directory for dynamic path resolution
+    const currentDir = process.cwd();
+    const indexJsPath = path.join(currentDir, 'index.js');
+
+    // Verify index.js exists
+    try {
+      await fs.access(indexJsPath);
+      console.log(chalk.green(`✅ Found eck-snapshot index.js at: ${indexJsPath}`));
+    } catch (error) {
+      console.error(chalk.red(`❌ Could not find index.js at: ${indexJsPath}`));
+      console.log(chalk.yellow('💡 Make sure you are running this command from the eck-snapshot project directory'));
+      process.exit(1);
+    }
+
+    // Create gemini tools directory
+    const homeDir = os.homedir();
+    const geminiToolsDir = path.join(homeDir, '.gemini', 'tools');
+
+    try {
+      await fs.mkdir(geminiToolsDir, { recursive: true });
+      console.log(chalk.green(`✅ Created/verified gemini tools directory: ${geminiToolsDir}`));
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to create gemini tools directory: ${error.message}`));
+      process.exit(1);
+    }
+
+    // Read environment variables from setup.json if available
+    let envVars = {};
+    try {
+      const setupJsonPath = path.join(currentDir, 'setup.json');
+      const setupContent = await fs.readFile(setupJsonPath, 'utf-8');
+      const setupData = JSON.parse(setupContent);
+
+      // Extract relevant environment variables
+      if (setupData.environmentDetection) {
+        envVars.ECK_SNAPSHOT_PATH = currentDir;
+        console.log(chalk.blue(`📋 Using project context from setup.json`));
+      }
+    } catch (error) {
+      console.log(chalk.yellow('⚠️  setup.json not found or invalid, using defaults'));
+    }
+
+    // Generate claude.toml content with dynamic paths
+    const claudeTomlContent = generateClaudeToml(indexJsPath, envVars);
+
+    // Write claude.toml file
+    const claudeTomlPath = path.join(geminiToolsDir, 'claude.toml');
+    try {
+      await fs.writeFile(claudeTomlPath, claudeTomlContent, 'utf-8');
+      console.log(chalk.green(`✅ Generated claude.toml at: ${claudeTomlPath}`));
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to write claude.toml: ${error.message}`));
+      process.exit(1);
+    }
+
+    // Success summary
+    console.log(chalk.green('\n🎉 Setup completed successfully!'));
+    console.log(chalk.blue('\n📋 Configuration summary:'));
+    console.log(chalk.cyan(`   • gemini-cli: ${geminiCliPath}`));
+    console.log(chalk.cyan(`   • eck-snapshot: ${indexJsPath}`));
+    console.log(chalk.cyan(`   • claude.toml: ${claudeTomlPath}`));
+
+    if (Object.keys(envVars).length > 0) {
+      console.log(chalk.cyan(`   • Environment variables: ${Object.keys(envVars).join(', ')}`));
+    }
+
+    console.log(chalk.blue('\n🚀 You can now use:'));
+    console.log(chalk.cyan('   gemini-cli claude "Your prompt here"'));
+    console.log(chalk.green('\n✨ Cross-platform path resolution is automatically handled!'));
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Setup failed: ${error.message}`));
+    if (options.verbose) {
+      console.error(chalk.red('Stack trace:'), error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Generates claude.toml content with dynamic paths
+ * @param {string} indexJsPath - Path to eck-snapshot index.js
+ * @param {Object} envVars - Environment variables to include
+ * @returns {string} - Generated TOML content
+ */
+function generateClaudeToml(indexJsPath, envVars = {}) {
+  const envSection = Object.keys(envVars).length > 0
+    ? `# Environment variables from setup.json
+${Object.entries(envVars).map(([key, value]) => `${key} = "${value}"`).join('\n')}
+
+`
+    : '';
+
+  return `# Claude.toml - Dynamic configuration for eck-snapshot integration
+# Generated automatically by 'eck-snapshot setup-gemini'
+# This file uses dynamic paths to work across WSL/Windows environments
+
+${envSection}[claude]
+# eck-snapshot integration for AI-powered repository analysis
+name = "eck-snapshot"
+description = "AI-powered repository snapshot and analysis tool with cross-platform support"
+command = "node"
+args = ["${indexJsPath}", "ask-claude"]
+
+# Command examples:
+# gemini-cli claude "Create a snapshot of the current project"
+# gemini-cli claude "Analyze the database structure"
+# gemini-cli claude "Generate a project overview"
+
+[claude.metadata]
+version = "4.0.0"
+author = "eck-snapshot"
+generated_at = "${new Date().toISOString()}"
+platform = "${process.platform}"
+node_version = "${process.version}"
+working_directory = "${path.dirname(indexJsPath)}"
+
+# Cross-platform compatibility notes:
+# - Paths are automatically resolved using process.cwd()
+# - Works in WSL, Windows, macOS, and Linux
+# - No hardcoded /mnt/c/ paths required
+`;
+}