@xelth/eck-snapshot 5.8.6 → 6.0.0

package/src/utils/telemetry.js

@@ -0,0 +1,98 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+
+const TELEMETRY_URL = 'https://xelth.com/T/report';
+
+/**
+ * Parses the AnswerToSA.md file to extract telemetry data.
+ * @param {string} content The markdown content
+ * @returns {object|null} The parsed telemetry data or null if invalid
+ */
+export function parseAgentReport(content) {
+  if (!content) return null;
+
+  const data = {
+    model_name: 'Unknown',
+    agent_role: 'Coder',
+    task_scope: 'general',
+    status: 'UNKNOWN',
+    duration_sec: null,
+    error_summary: null
+  };
+
+  // Extract Executor (Model Name)
+  const executorMatch = content.match(/\*\*Executor:\*\*\s*(.+)/i);
+  if (executorMatch) {
+    data.model_name = executorMatch[1].trim();
+  }
+
+  // Extract Status
+  const statusMatch = content.match(/\*\*Status:\*\*\s*\[?(SUCCESS|FAILED|BLOCKED)\]?/i);
+  if (statusMatch) {
+    data.status = statusMatch[1].toUpperCase();
+  }
+
+  // Extract Task Name / Scope
+  const titleMatch = content.match(/#\s*Report:\s*(.+)/i);
+  if (titleMatch) {
+    data.task_scope = titleMatch[1].trim().substring(0, 100);
+  }
+
+  // If failed/blocked, capture next few lines as error summary
+  if (data.status === 'FAILED' || data.status === 'BLOCKED') {
+    const lines = content.split('\n');
+    const statusIndex = lines.findIndex(l => l.match(/\*\*Status:\*\*/i));
+    if (statusIndex !== -1 && statusIndex + 1 < lines.length) {
+      data.error_summary = lines.slice(statusIndex + 1, statusIndex + 4).join(' ').trim().substring(0, 500);
+    }
+  }
+
+  return data;
+}
+
+/**
+ * Reads the latest report and pushes it to the telemetry server.
+ * @param {string} repoPath
+ * @param {boolean} silent If true, suppresses console output (for automated runs)
+ */
+export async function pushTelemetry(repoPath, silent = false) {
+  const reportPath = path.join(repoPath, '.eck', 'lastsnapshot', 'AnswerToSA.md');
+
+  try {
+    const content = await fs.readFile(reportPath, 'utf-8');
+
+    // Don't push if already pushed
+    if (content.includes('[TELEMETRY: PUSHED]')) {
+      if (!silent) console.log(chalk.yellow('i  Telemetry already pushed for this report.'));
+      return;
+    }
+
+    const payload = parseAgentReport(content);
+    if (!payload || payload.status === 'UNKNOWN') {
+      if (!silent) console.log(chalk.yellow('i  Could not parse a valid agent report for telemetry.'));
+      return;
+    }
+
+    const response = await fetch(TELEMETRY_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload)
+    });
+
+    if (response.ok) {
+      if (!silent) console.log(chalk.green(`Telemetry pushed successfully for ${payload.model_name} (${payload.status})`));
+      await fs.appendFile(reportPath, '\n\n[TELEMETRY: PUSHED]\n', 'utf-8');
+    } else {
+      if (!silent) console.log(chalk.red(`Telemetry push failed: ${response.statusText}`));
+    }
+  } catch (error) {
+    if (!silent) {
+      if (error.code === 'ENOENT') {
+        console.log(chalk.yellow('i  No AnswerToSA.md found. Nothing to push.'));
+      } else {
+        console.log(chalk.red(`Telemetry error: ${error.message}`));
+      }
+    }
+  }
+}

package/src/utils/tokenEstimator.js

@@ -117,8 +117,50 @@ export async function addTrainingPoint(projectType, fileSizeInBytes, estimatedTo
   console.log(`   Estimated: ${estimatedTokens} tokens`);
   console.log(`   Actual: ${actualTokens} tokens`);
   console.log(`   Error: ${Math.abs(actualTokens - estimatedTokens)} tokens (${Math.round(Math.abs(actualTokens - estimatedTokens) / actualTokens * 100)}%)`);
+
+  // Push training point to Telemetry Hub
+  try {
+    const res = await fetch('https://xelth.com/T/tokens/train', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        project_type: projectType,
+        file_size_bytes: fileSizeInBytes,
+        actual_tokens: actualTokens
+      })
+    });
+    if (res.ok) {
+      console.log('   Training point pushed to Telemetry Hub');
+    }
+  } catch (e) {
+    // Fail silently, network might be down
+  }
 }
 
+/**
+ * Fetch global token weights from Telemetry Hub and merge them into local training data
+ */
+export async function syncTokenWeights(silent = false) {
+  try {
+    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();
+
+    if (data && data.coefficients && Object.keys(data.coefficients).length > 0) {
+      const localData = await loadTrainingData();
+      // Global coefficients override local ones
+      localData.coefficients = { ...localData.coefficients, ...data.coefficients };
+      await saveTrainingData(localData);
+      if (!silent) console.log('Global token weights synchronized successfully.');
+    } else {
+      if (!silent) console.log('No global weights available yet.');
+    }
+  } catch (e) {
+    if (!silent) console.log('Failed to sync token weights: ' + e.message);
+  }
+}
+
 /**
  * Update polynomial coefficients using least squares fitting
  * For now, we'll use a simple adaptive approach
@@ -175,27 +217,31 @@ function updateCoefficients(data, projectType) {
   ];
 }
 
-/**
- * Show current estimation statistics
- */
-export async function showEstimationStats() {
-  const data = await loadTrainingData();
-  
-  console.log('\n📊 Token Estimation Statistics:');
-  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-  
-  for (const [projectType, coefficients] of Object.entries(data.coefficients)) {
-    const points = data.trainingPoints[projectType] || [];
-    console.log(`\n🔸 ${projectType}:`);
-    console.log(`   Coefficients: [${coefficients.map(c => c.toFixed(6)).join(', ')}]`);
-    console.log(`   Training points: ${points.length}`);
-    
-    if (points.length > 0) {
-      const errors = points.map(p => Math.abs(p.actualTokens - p.estimatedTokens));
-      const avgError = errors.reduce((a, b) => a + b, 0) / errors.length;
-      console.log(`   Average error: ${Math.round(avgError)} tokens`);
-    }
-  }
-  
-  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+/**
+ * Show current estimation statistics
+ */
+export async function showEstimationStats() {
+  const data = await loadTrainingData();
+  
+  console.log('\n📊 Token Estimation Statistics:');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  
+  for (const [projectType, coefficients] of Object.entries(data.coefficients)) {
+    const points = data.trainingPoints[projectType] || [];
+    console.log(`\n🔸 ${projectType}:`);
+    console.log(`   Coefficients: [${coefficients.map(c => c.toFixed(6)).join(', ')}]`);
+    console.log(`   Training points: ${points.length}`);
+    
+    if (points.length > 0) {
+      // 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`);
+    }
+  }
+  
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
 }