@xelth/eck-snapshot 2.2.0 → 4.0.0

package/src/cli/commands/setupGemini.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+
+describe('setupGemini integration', () => {
+  it('should validate path resolution logic', () => {
+    // Test path join functionality that setupGemini uses
+    const currentDir = '/test/project';
+    const indexJsPath = `${currentDir}/index.js`;
+
+    expect(indexJsPath).toBe('/test/project/index.js');
+    expect(indexJsPath).toContain('index.js');
+  });
+
+  it('should validate gemini tools directory structure', () => {
+    const homeDir = '/home/user';
+    const geminiToolsDir = `${homeDir}/.gemini/tools`;
+    const claudeTomlPath = `${geminiToolsDir}/claude.toml`;
+
+    expect(geminiToolsDir).toBe('/home/user/.gemini/tools');
+    expect(claudeTomlPath).toBe('/home/user/.gemini/tools/claude.toml');
+  });
+
+  it('should validate TOML content structure', () => {
+    const indexJsPath = '/test/project/index.js';
+    const envVars = { ECK_SNAPSHOT_PATH: '/test/project' };
+
+    // Test environment section generation
+    const envSection = Object.keys(envVars).length > 0
+      ? `# Environment variables from setup.json\n${Object.entries(envVars).map(([key, value]) => `${key} = "${value}"`).join('\n')}\n\n`
+      : '';
+
+    // Test main TOML structure
+    const tomlContent = `# Claude.toml - Dynamic configuration for eck-snapshot integration
+# Generated automatically by 'eck-snapshot setup-gemini'
+
+${envSection}[claude]
+name = "eck-snapshot"
+description = "AI-powered repository snapshot and analysis tool with cross-platform support"
+command = "node"
+args = ["${indexJsPath}", "ask-claude"]
+
+[claude.metadata]
+version = "4.0.0"
+author = "eck-snapshot"
+platform = "${process.platform}"
+working_directory = "${indexJsPath.replace('/index.js', '')}"`;
+
+    expect(tomlContent).toContain('[claude]');
+    expect(tomlContent).toContain('name = "eck-snapshot"');
+    expect(tomlContent).toContain(`args = ["${indexJsPath}", "ask-claude"]`);
+    expect(tomlContent).toContain('[claude.metadata]');
+    expect(tomlContent).toContain('ECK_SNAPSHOT_PATH = "/test/project"');
+  });
+
+  it('should handle cross-platform paths correctly', () => {
+    const testPaths = [
+      { platform: 'windows', path: 'C:\\Users\\test\\project\\index.js' },
+      { platform: 'unix', path: '/home/user/project/index.js' },
+      { platform: 'wsl', path: '/mnt/c/Users/test/project/index.js' }
+    ];
+
+    testPaths.forEach(({ platform, path }) => {
+      expect(path).toContain('index.js');
+      expect(path.length).toBeGreaterThan(0);
+
+      // Test that the path is absolute (platform-appropriate)
+      if (platform === 'windows') {
+        expect(path).toMatch(/^[A-Z]:\\/);
+      } else {
+        expect(path).toMatch(/^\//);
+      }
+    });
+  });
+
+  it('should validate error handling patterns', () => {
+    // Test error message patterns that setupGemini should handle
+    const errorPatterns = [
+      'gemini-cli not found in PATH',
+      'Could not find index.js',
+      'Failed to create gemini tools directory',
+      'Failed to write claude.toml'
+    ];
+
+    errorPatterns.forEach(pattern => {
+      expect(pattern).toBeDefined();
+      expect(typeof pattern).toBe('string');
+      expect(pattern.length).toBeGreaterThan(0);
+    });
+  });
+
+  it('should test JSON parsing for setup.json', () => {
+    const validSetupData = {
+      environmentDetection: {
+        detected: true
+      }
+    };
+
+    const jsonString = JSON.stringify(validSetupData);
+    const parsed = JSON.parse(jsonString);
+
+    expect(parsed.environmentDetection).toBeDefined();
+    expect(parsed.environmentDetection.detected).toBe(true);
+
+    // Test invalid JSON handling pattern
+    const invalidJson = 'invalid json {';
+    let parseError = null;
+    try {
+      JSON.parse(invalidJson);
+    } catch (e) {
+      parseError = e;
+    }
+
+    expect(parseError).toBeDefined();
+    expect(parseError.message).toContain('JSON');
+  });
+});

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/config.js

@@ -0,0 +1,81 @@
+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);
+    return cachedConfig;
+  } catch (error) {
+    console.error('Error loading setup.json:', error.message);
+    throw new Error('Failed to load setup.json configuration file');
+  }
+}
+
+/**
+ * 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
+};

package/src/services/authService.js

@@ -0,0 +1,20 @@
+import ora from 'ora';
+import { execa } from 'execa';
+
+/**
+ * Initiates the interactive login flow by spawning 'codex login'.
+ * This will open a browser and wait for the user to complete authentication.
+ * @returns {Promise<void>}
+ */
+export async function initiateLogin() {
+  const spinner = ora('Authentication required. Please follow the browser instructions.').start();
+  try {
+    // Run `codex login` interactively, inheriting stdio to show user instructions.
+    await execa('codex', ['login'], { stdio: 'inherit' });
+    spinner.succeed('Login successful. Retrying original command...');
+  } catch (e) {
+    spinner.fail('Login process failed or was cancelled.');
+    // Re-throw to notify p-retry that the attempt failed.
+    throw new Error(`Login failed: ${e.message}`);
+  }
+}