@xelth/eck-snapshot 5.9.0 → 6.4.0

package/src/utils/gitUtils.js

@@ -25,14 +25,18 @@ export async function getGitAnchor(repoPath) {
   }
 }
 
-export async function getChangedFiles(repoPath, anchorHash) {
-  try {
-    const { stdout } = await execa('git', ['diff', '--name-only', anchorHash, 'HEAD'], { cwd: repoPath });
-    return stdout.split('\n').filter(Boolean);
-  } catch (e) {
-    throw new Error(`Failed to get git diff: ${e.message}`);
-  }
-}
+export async function getChangedFiles(repoPath, anchorHash, includeWorkingTree = false) {
+  try {
+    const args = ['diff', '--name-only', anchorHash];
+    if (!includeWorkingTree) {
+      args.push('HEAD');
+    }
+    const { stdout } = await execa('git', args, { cwd: repoPath });
+    return stdout.split('\n').filter(Boolean);
+  } catch (e) {
+    throw new Error(`Failed to get git diff: ${e.message}`);
+  }
+}
 
 export async function getGitDiffOutput(repoPath, anchorHash, excludeFiles = []) {
   try {

package/src/utils/opencodeAgentsGenerator.js

@@ -1,5 +1,9 @@
 import fs from 'fs/promises';
 import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 /**
  * Generates AGENTS.md for OpenCode integration (GLM Z.AI ecosystem only)
@@ -30,11 +34,12 @@ export async function generateOpenCodeAgents(repoPath, mode, tree, confidentialF
       color: '#10a37f'
     };
 
-    const templatePath = path.join(repoPath, '..', '..', 'src', 'templates', 'opencode', 'junior-architect.template.md');
+    const templatePath = path.join(__dirname, '..', 'templates', 'opencode', 'junior-architect.template.md');
     try {
       let templateContent = await fs.readFile(templatePath, 'utf-8');
       body = templateContent.replace('{{tree}}', tree);
     } catch (error) {
+      console.warn(`⚠️ Could not load JAZ template from ${templatePath}: ${error.message}`);
       body = `# 🧠 ROLE: Swarm Orchestrator (GLM-4.7)\n\nDirectory:\n\`\`\`\n${tree}\n\`\`\``;
     }
   } else {
@@ -48,10 +53,11 @@ export async function generateOpenCodeAgents(repoPath, mode, tree, confidentialF
       color: '#44BA81'
     };
 
-    const templatePath = path.join(repoPath, '..', '..', 'src', 'templates', 'opencode', 'coder.template.md');
+    const templatePath = path.join(__dirname, '..', 'templates', 'opencode', 'coder.template.md');
     try {
       body = await fs.readFile(templatePath, 'utf-8');
     } catch (error) {
+      console.warn(`⚠️ Could not load Coder template from ${templatePath}: ${error.message}`);
       body = `# 🛠️ ROLE: Expert Developer`;
     }
   }

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}`);
-  }
-}