knoxis-helper 1.4.5 → 1.4.6

package/lib/knoxis-pair-program.js

@@ -5,6 +5,24 @@ const path = require('path');
 const os = require('os');
 const { spawn, spawnSync, execSync } = require('child_process');
 
+// ===== RETRY CONFIGURATION =====
+// Can be overridden via environment variables
+const RETRY_CONFIG = {
+  maxRetries: parseInt(process.env.KNOXIS_MAX_RETRIES || '3'),
+  retryDelay: parseInt(process.env.KNOXIS_RETRY_DELAY || '30000'), // 30 seconds
+  gitTimeout: parseInt(process.env.KNOXIS_GIT_TIMEOUT || '30000'), // 30 seconds
+  aiCallTimeout: parseInt(process.env.KNOXIS_AI_TIMEOUT || '300000'), // 5 minutes
+  enableRetryLogging: process.env.KNOXIS_RETRY_LOG !== 'false'
+};
+
+// Global retry statistics
+let retryStats = {
+  totalRetries: 0,
+  successfulRetries: 0,
+  failedCommands: [],
+  startTime: Date.now()
+};
+
 function parseArgs(argv) {
   const args = {};
   const multi = {};
@@ -59,7 +77,45 @@ function commandExists(cmd) {
   return result.status === 0;
 }
 
-// Resolve workspace name to path using knoxis registry
+// Resolve workspace name to path using knoxis registry (async version)
+async function resolveWorkspacePathAsync(nameOrPath) {
+  const os = require('os');
+
+  // Direct path - check if exists
+  try {
+    await fs.promises.stat(nameOrPath);
+    return path.resolve(nameOrPath);
+  } catch (e) {
+    // Not a direct path, continue
+  }
+
+  // Try knoxis workspace registry
+  const workspacesFile = path.join(os.homedir(), '.knoxis', 'workspaces.json');
+  try {
+    const data = await fs.promises.readFile(workspacesFile, 'utf8');
+    const workspaces = JSON.parse(data);
+
+    // Exact match
+    if (workspaces[nameOrPath]) {
+      return workspaces[nameOrPath];
+    }
+
+    // Fuzzy match
+    const lower = nameOrPath.toLowerCase();
+    for (const [name, wsPath] of Object.entries(workspaces)) {
+      if (name.toLowerCase().includes(lower)) {
+        console.log(`Matched workspace: ${name} -> ${wsPath}`);
+        return wsPath;
+      }
+    }
+  } catch (e) {
+    // Registry file not found or parse error
+  }
+
+  return null;
+}
+
+// Sync version kept for backward compatibility
 function resolveWorkspacePath(nameOrPath) {
   const os = require('os');
 
@@ -132,32 +188,62 @@ function toArray(value) {
   return [value];
 }
 
-function gatherContext(workspace, inputs) {
+async function gatherContext(workspace, inputs) {
   const sections = [];
   const labels = [];
   const seen = new Set();
+  const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB limit
+  const ALLOWED_EXTENSIONS = /\.(js|jsx|ts|tsx|java|py|json|md|txt|yml|yaml|xml|html|css|scss|sql|sh|bash|env|config|conf)$/i;
 
-  toArray(inputs).forEach(entry => {
+  for (const entry of toArray(inputs)) {
     if (typeof entry !== 'string') {
-      return;
+      continue;
     }
     const trimmed = entry.trim();
     if (!trimmed) {
-      return;
+      continue;
     }
     const absolute = path.isAbsolute(trimmed) ? trimmed : path.join(workspace, trimmed);
-    if (!fs.existsSync(absolute)) {
-      return;
-    }
-    if (seen.has(absolute)) {
-      return;
+
+    try {
+      const stats = await fs.promises.stat(absolute);
+
+      // Skip directories
+      if (stats.isDirectory()) {
+        console.warn(`[Context] Skipping directory: ${absolute}`);
+        continue;
+      }
+
+      // Skip if already processed
+      if (seen.has(absolute)) {
+        continue;
+      }
+
+      // Check file size
+      if (stats.size > MAX_FILE_SIZE) {
+        console.warn(`[Context] Skipping large file (${(stats.size/1048576).toFixed(2)}MB): ${absolute}`);
+        labels.push(path.basename(absolute) + ' [too large]');
+        sections.push(formatSection(path.basename(absolute), `[File too large: ${(stats.size/1048576).toFixed(2)}MB]`));
+        continue;
+      }
+
+      // Check file extension
+      if (!ALLOWED_EXTENSIONS.test(absolute)) {
+        console.warn(`[Context] Skipping non-text file: ${absolute}`);
+        continue;
+      }
+
+      seen.add(absolute);
+      const content = await fs.promises.readFile(absolute, 'utf8');
+      const title = path.relative(workspace, absolute) || path.basename(absolute);
+      labels.push(title);
+      sections.push(formatSection(title, content));
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        console.error(`[Context] Error reading ${absolute}: ${err.message}`);
+      }
     }
-    seen.add(absolute);
-    const content = fs.readFileSync(absolute, 'utf8');
-    const title = path.relative(workspace, absolute) || path.basename(absolute);
-    labels.push(title);
-    sections.push(formatSection(title, content));
-  });
+  }
 
   return { sections, labels };
 }
@@ -309,7 +395,7 @@ function buildPrompt(options) {
   return sections.join('\n\n');
 }
 
-async function callAi(aiConfig, prompt, livePrinter) {
+async function callAiBase(aiConfig, prompt, livePrinter) {
   return new Promise((resolve, reject) => {
     const proc = spawn(aiConfig.cmd, aiConfig.args, { stdio: ['pipe', 'pipe', 'pipe'] });
     let stdout = '';
@@ -350,6 +436,60 @@ async function callAi(aiConfig, prompt, livePrinter) {
   });
 }
 
+async function callAi(aiConfig, prompt, livePrinter, options = {}) {
+  const maxRetries = options.maxRetries || RETRY_CONFIG.maxRetries;
+  const retryDelay = options.retryDelay || RETRY_CONFIG.retryDelay;
+  const enableLogging = options.silent === false || RETRY_CONFIG.enableRetryLogging;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const timestamp = new Date().toISOString();
+      if (enableLogging) {
+        console.log(`[${timestamp}] [AI Call - Attempt ${attempt}/${maxRetries}] Invoking ${aiConfig.label}...`);
+      }
+      if (attempt > 1) {
+        retryStats.totalRetries++;
+      }
+
+      const result = await callAiBase(aiConfig, prompt, livePrinter);
+
+      if (attempt > 1) {
+        retryStats.successfulRetries++;
+        if (enableLogging) {
+          console.log(`[AI Call - Success] Recovered after ${attempt} attempts`);
+        }
+      }
+      return result;
+    } catch (error) {
+      const isLastAttempt = attempt === maxRetries;
+      const timestamp = new Date().toISOString();
+
+      if (enableLogging) {
+        console.error(`[${timestamp}] [AI Call - Attempt ${attempt}/${maxRetries}] Failed`);
+        console.error(`  Provider: ${aiConfig.label}`);
+        console.error(`  Error: ${error.message}`);
+      }
+
+      if (!isLastAttempt) {
+        if (enableLogging) {
+          console.log(`[AI Call - Retry] Waiting ${retryDelay/1000} seconds before retry...`);
+        }
+        await new Promise(resolve => setTimeout(resolve, retryDelay));
+      } else {
+        if (enableLogging) {
+          console.error(`[AI Call - Failed] Max retries reached. AI call failed permanently.`);
+        }
+        retryStats.failedCommands.push({
+          command: `AI call to ${aiConfig.label}`,
+          error: error.message,
+          timestamp: timestamp
+        });
+        throw error;
+      }
+    }
+  }
+}
+
 // ===== SESSION RECORDING =====
 // Records full prompts, responses, git diffs, and timing for model training
 
@@ -359,8 +499,134 @@ function ensureSessionDir() {
   if (!fs.existsSync(SESSIONS_DIR)) fs.mkdirSync(SESSIONS_DIR, { recursive: true });
 }
 
-function safeExec(cmd, cwd) {
-  try { return execSync(cmd, { cwd, encoding: 'utf8', timeout: 10000 }).trim(); } catch (e) { return null; }
+// Async version with proper setTimeout
+async function safeExecAsync(cmd, cwd, options = {}) {
+  const { exec } = require('child_process');
+  const util = require('util');
+  const execAsync = util.promisify(exec);
+
+  const maxRetries = options.maxRetries || RETRY_CONFIG.maxRetries;
+  const retryDelay = options.retryDelay || RETRY_CONFIG.retryDelay;
+  const timeout = options.timeout || RETRY_CONFIG.gitTimeout;
+  const silent = options.silent || !RETRY_CONFIG.enableRetryLogging;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      if (!silent && attempt > 1) {
+        console.log(`[Git Retry ${attempt}/${maxRetries}] Executing: ${cmd.substring(0, 50)}...`);
+        retryStats.totalRetries++;
+      }
+
+      const { stdout } = await execAsync(cmd, {
+        cwd,
+        encoding: 'utf8',
+        timeout,
+        maxBuffer: 10 * 1024 * 1024 // 10MB buffer
+      });
+
+      const result = stdout.trim();
+
+      if (attempt > 1) {
+        retryStats.successfulRetries++;
+        if (!silent) {
+          console.log(`[Git Success] Command recovered after ${attempt} attempts`);
+        }
+      }
+      return result;
+    } catch (e) {
+      const isLastAttempt = attempt === maxRetries;
+      if (!silent) {
+        const timestamp = new Date().toISOString();
+        console.error(`[${timestamp}] [Git Attempt ${attempt}/${maxRetries}] Command failed: ${cmd.substring(0, 50)}...`);
+        console.error(`  Error: ${e.message || 'Unknown error'}`);
+        if (e.code === 'ETIMEDOUT') {
+          console.error(`  Timeout after ${timeout/1000} seconds`);
+        }
+      }
+
+      if (!isLastAttempt) {
+        if (!silent) {
+          console.log(`  Waiting ${retryDelay/1000} seconds before retry...`);
+        }
+        // Proper async delay
+        await new Promise(resolve => setTimeout(resolve, retryDelay));
+      } else {
+        if (!silent) {
+          console.error(`  Max retries reached. Command failed permanently.`);
+        }
+        retryStats.failedCommands.push({
+          command: cmd.substring(0, 100),
+          error: e.message,
+          timestamp: new Date().toISOString()
+        });
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+// Sync version (kept for backward compatibility)
+function safeExec(cmd, cwd, options = {}) {
+  const maxRetries = options.maxRetries || RETRY_CONFIG.maxRetries;
+  const retryDelay = options.retryDelay || RETRY_CONFIG.retryDelay;
+  const timeout = options.timeout || RETRY_CONFIG.gitTimeout;
+  const silent = options.silent || !RETRY_CONFIG.enableRetryLogging;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      if (!silent && attempt > 1) {
+        console.log(`[Git Retry ${attempt}/${maxRetries}] Executing: ${cmd.substring(0, 50)}...`);
+        retryStats.totalRetries++;
+      }
+      const result = execSync(cmd, { cwd, encoding: 'utf8', timeout }).trim();
+      if (attempt > 1) {
+        retryStats.successfulRetries++;
+        if (!silent) {
+          console.log(`[Git Success] Command recovered after ${attempt} attempts`);
+        }
+      }
+      return result;
+    } catch (e) {
+      const isLastAttempt = attempt === maxRetries;
+      if (!silent) {
+        const timestamp = new Date().toISOString();
+        console.error(`[${timestamp}] [Git Attempt ${attempt}/${maxRetries}] Command failed: ${cmd.substring(0, 50)}...`);
+        console.error(`  Error: ${e.message || 'Unknown error'}`);
+        if (e.code === 'ETIMEDOUT') {
+          console.error(`  Timeout after ${timeout/1000} seconds`);
+        }
+      }
+
+      if (!isLastAttempt) {
+        if (!silent) {
+          console.log(`  Waiting ${retryDelay/1000} seconds before retry...`);
+        }
+        // Cross-platform sleep
+        const sleepCmd = process.platform === 'win32'
+          ? `powershell -Command "Start-Sleep -Seconds ${retryDelay/1000}"`
+          : `sleep ${retryDelay/1000}`;
+        try {
+          execSync(sleepCmd, { stdio: 'ignore' });
+        } catch (sleepError) {
+          // If sleep command fails, we have to skip the delay
+          // Busy-wait is too CPU intensive and blocks the event loop
+          console.warn(`[Warning] Unable to sleep between retries, continuing immediately`);
+        }
+      } else {
+        if (!silent) {
+          console.error(`  Max retries reached. Command failed permanently.`);
+        }
+        retryStats.failedCommands.push({
+          command: cmd.substring(0, 100),
+          error: e.message,
+          timestamp: new Date().toISOString()
+        });
+        return null;
+      }
+    }
+  }
+  return null;
 }
 
 function slugify(text) {
@@ -404,6 +670,34 @@ class SessionRecorder {
     s.error = error || null;
   }
 
+  async saveAsync() {
+    const record = {
+      sessionId: this.sessionId, version: '1.0.0',
+      task: this.task, workspace: this.workspace, aiProvider: this.aiProvider,
+      startedAt: this.startedAt, completedAt: new Date().toISOString(),
+      totalDurationMs: Date.now() - new Date(this.startedAt).getTime(),
+      steps: this.steps,
+      totalSteps: this.steps.length,
+      completedSteps: this.steps.filter(s => s.completedAt && !s.error).length,
+      git: {
+        initialCommit: this.initialCommit,
+        finalCommit: await safeExecAsync('git rev-parse --short HEAD', this.workspace) || '',
+        totalDiff: await safeExecAsync('git diff', this.workspace) || ''
+      },
+      environment: { platform: os.platform(), nodeVersion: process.version }
+    };
+    const filename = `${this.sessionId}-${slugify(this.task)}.json`;
+    const filepath = path.join(SESSIONS_DIR, filename);
+    await fs.promises.writeFile(filepath, JSON.stringify(record, null, 2), 'utf8');
+    // Append to index
+    try {
+      await fs.promises.appendFile(path.join(SESSIONS_DIR, 'index.jsonl'),
+        JSON.stringify({ sessionId: record.sessionId, task: record.task, startedAt: record.startedAt, totalDurationMs: record.totalDurationMs, file: filename }) + '\n');
+    } catch (e) {}
+    return filepath;
+  }
+
+  // Sync version kept for backward compatibility
   save() {
     const record = {
       sessionId: this.sessionId, version: '1.0.0',
@@ -484,7 +778,7 @@ async function run() {
     globalContextInputs.push(timeline.sharedContext);
   }
 
-  const globalContext = gatherContext(workspace, globalContextInputs);
+  const globalContext = await gatherContext(workspace, globalContextInputs);
   const globalContextBlock = globalContext.sections.join('\n\n');
 
   let scheduledSteps;
@@ -557,7 +851,7 @@ IMPORTANT: Work autonomously. Do not ask questions or wait for confirmation. Mak
 Only work inside the provided workspace and preserve user data.`;
 
   for (const step of scheduledSteps) {
-    const stepContext = gatherContext(workspace, step.contextPaths);
+    const stepContext = await gatherContext(workspace, step.contextPaths);
     if (stepContext.labels.length) {
       console.log(`Step context for ${step.displayName}: ${stepContext.labels.join(', ')}`);
       console.log('');
@@ -614,10 +908,49 @@ Only work inside the provided workspace and preserve user data.`;
     console.log('');
   }
 
+  // Print retry statistics if any retries occurred
+  printRetryStatistics();
+
   console.log('Session complete. Knoxis and the AI partner are standing by for further instructions.');
 }
 
+function printRetryStatistics() {
+  if (retryStats.totalRetries === 0 && retryStats.failedCommands.length === 0) {
+    return; // No retries needed, don't print stats
+  }
+
+  console.log('');
+  console.log('===== RETRY STATISTICS =====');
+  console.log(`Total Retries: ${retryStats.totalRetries}`);
+  console.log(`Successful Recoveries: ${retryStats.successfulRetries}`);
+  console.log(`Failed After Max Retries: ${retryStats.failedCommands.length}`);
+
+  if (retryStats.failedCommands.length > 0) {
+    console.log('\nFailed Commands:');
+    retryStats.failedCommands.forEach((failure, index) => {
+      console.log(`  ${index + 1}. [${failure.timestamp}]`);
+      console.log(`     Command: ${failure.command}`);
+      console.log(`     Error: ${failure.error}`);
+    });
+  }
+
+  const sessionDuration = Date.now() - retryStats.startTime;
+  const minutes = Math.floor(sessionDuration / 60000);
+  const seconds = Math.floor((sessionDuration % 60000) / 1000);
+  console.log(`\nSession Duration: ${minutes}m ${seconds}s`);
+
+  if (retryStats.totalRetries > 0) {
+    const retryOverhead = retryStats.totalRetries * RETRY_CONFIG.retryDelay;
+    const overheadMinutes = Math.floor(retryOverhead / 60000);
+    const overheadSeconds = Math.floor((retryOverhead % 60000) / 1000);
+    console.log(`Estimated Retry Overhead: ${overheadMinutes}m ${overheadSeconds}s`);
+  }
+  console.log('============================');
+  console.log('');
+}
+
 run().catch(err => {
-  console.error(err.message);
+  console.error('Fatal error:', err.message);
+  printRetryStatistics();
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knoxis-helper",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "description": "Local helper for Knoxis pair programming - connects your machine to Knoxis on qig.ai",
   "bin": {
     "knoxis-helper": "./bin/knoxis-helper.js"