knoxis-collab 1.3.0 → 1.4.0

package/knoxis-collab.js

@@ -38,8 +38,22 @@
 const { spawn, spawnSync } = require('child_process');
 const crypto = require('crypto');
 const https = require('https');
+
+// Create HTTP agents with connection keep-alive
+const httpAgent = new (require('http').Agent)({
+  keepAlive: true,
+  keepAliveMsecs: 1000,
+  maxSockets: 10
+});
+
+const httpsAgent = new https.Agent({
+  keepAlive: true,
+  keepAliveMsecs: 1000,
+  maxSockets: 10
+});
 const readline = require('readline');
 const fs = require('fs');
+const fsPromises = require('fs').promises;
 const path = require('path');
 const os = require('os');
 
@@ -71,7 +85,20 @@ const cliArgs = parseArgs();
 const WORKSPACE = cliArgs.workspace || process.env.KNOXIS_WORKSPACE || process.cwd();
 
 // Load config
-function loadConfig() {
+async function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const data = await fsPromises.readFile(CONFIG_PATH, 'utf8');
+      return JSON.parse(data);
+    }
+  } catch (e) {
+    console.error(`Failed to load config: ${e.message}`);
+  }
+  return {};
+}
+
+// Synchronous config load for initialization
+function loadConfigSync() {
   try {
     if (fs.existsSync(CONFIG_PATH)) {
       return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
@@ -80,7 +107,7 @@ function loadConfig() {
   return {};
 }
 
-const config = loadConfig();
+const config = loadConfigSync();
 const GROQ_API_KEY = process.env.GROQ_API_KEY || config.groqApiKey || '';
 const BACKEND_URL = process.env.KNOXIS_BACKEND_URL || config.backendUrl || '';
 const USER_ID = process.env.KNOXIS_USER_ID || config.userId || '';
@@ -153,6 +180,7 @@ let isClaudeRunning = false;
 let activeClaudeProc = null;
 const conversationHistory = [];    // Groq message history
 const dispatchSummaries = [];      // Short summaries of what Claude did each dispatch
+const MAX_DISPATCH_SUMMARIES = 20; // Limit dispatch summaries for memory
 const aiInsights = {                // AI decision-making layer state
   projectType: null,
   complexity: 'medium',
@@ -174,6 +202,16 @@ const feedbackState = {
   awaitingRating: false             // Whether we're waiting for a rating
 };
 
+// Code review and commenting state
+const codeReview = {
+  pendingReviews: [],              // Code blocks awaiting review
+  reviewHistory: [],               // Past code reviews
+  inlineComments: new Map(),      // File -> line -> comment mapping
+  activeReviewSession: null,      // Current review session ID
+  autoReviewEnabled: false,       // Auto-review on code changes
+  lastReviewedCode: null           // Cache last reviewed code
+};
+
 // ═══════════════════════════════════════════════════════════════
 //  SESSION LOG & PERSISTENCE
 // ═══════════════════════════════════════════════════════════════
@@ -187,16 +225,36 @@ const logFile = path.join(
   `${new Date().toISOString().replace(/[:.]/g, '-')}-collab-${SESSION_ID.slice(0, 8)}.log`
 );
 
+// Async logging with queue for better performance
+const logQueue = [];
+let logTimer = null;
+
 function log(entry) {
   const line = `[${new Date().toISOString()}] ${entry}\n`;
-  try { fs.appendFileSync(logFile, line); } catch (e) {}
+  logQueue.push(line);
+
+  // Batch write logs every 100ms
+  if (!logTimer) {
+    logTimer = setTimeout(async () => {
+      if (logQueue.length > 0) {
+        const batch = logQueue.splice(0, logQueue.length).join('');
+        try {
+          await fsPromises.appendFile(logFile, batch);
+        } catch (e) {
+          console.error(`Log write failed: ${e.message}`);
+        }
+      }
+      logTimer = null;
+    }, 100);
+  }
 }
 
 // Load persisted feedback data
-function loadFeedbackData() {
+async function loadFeedbackData() {
   try {
     if (fs.existsSync(feedbackFile)) {
-      const data = JSON.parse(fs.readFileSync(feedbackFile, 'utf8'));
+      const content = await fsPromises.readFile(feedbackFile, 'utf8');
+      const data = JSON.parse(content);
 
       // Restore pattern weights
       if (data.patternWeights) {
@@ -225,7 +283,7 @@ function loadFeedbackData() {
 }
 
 // Save feedback data for persistence
-function saveFeedbackData() {
+async function saveFeedbackData() {
   try {
     const data = {
       version: '1.0',
@@ -235,13 +293,147 @@ function saveFeedbackData() {
       feedbackHistory: aiInsights.feedbackHistory.slice(-50) // Keep last 50
     };
 
-    fs.writeFileSync(feedbackFile, JSON.stringify(data, null, 2));
+    await fsPromises.writeFile(feedbackFile, JSON.stringify(data, null, 2));
     log(`Saved feedback data: ${aiInsights.patternWeights.size} patterns, ${aiInsights.suggestionScores.size} suggestions`);
   } catch (e) {
     log(`Failed to save feedback data: ${e.message}`);
   }
 }
 
+// ═══════════════════════════════════════════════════════════════
+//  CODE REVIEW AND COMMENTING FUNCTIONS
+// ═══════════════════════════════════════════════════════════════
+
+// Review code with inline comments
+async function reviewCode(code, filePath, startLine = 1) {
+  const reviewId = crypto.randomUUID().substring(0, 8);
+  codeReview.activeReviewSession = reviewId;
+
+  const review = {
+    id: reviewId,
+    timestamp: Date.now(),
+    filePath: filePath,
+    code: code,
+    startLine: startLine,
+    comments: [],
+    summary: null
+  };
+
+  // Call Groq for code review
+  const userPrompt = `You are a senior code reviewer. Review the following code and provide:
+1. Inline comments for specific lines (format: "Line X: comment")
+2. General feedback and suggestions
+3. Identify potential issues, bugs, or improvements
+Be constructive and specific. Focus on code quality, performance, security, and maintainability.
+
+Review this code from ${filePath} starting at line ${startLine}:
+
+${code}`;
+
+  try {
+    const reviewResponse = await callGroq(
+      [{ role: 'user', content: userPrompt }],
+      projectContext
+    );
+
+    // Extract text from Groq response object
+    const reviewText = reviewResponse.message || JSON.stringify(reviewResponse);
+
+    // Parse inline comments from response
+    const lines = reviewText.split('\n');
+    const inlineCommentPattern = /^Line\s+(\d+):\s*(.+)/i;
+
+    lines.forEach(line => {
+      const match = line.match(inlineCommentPattern);
+      if (match) {
+        const lineNum = parseInt(match[1]) + startLine - 1;
+        const comment = match[2].trim();
+
+        review.comments.push({
+          line: lineNum,
+          comment: comment,
+          severity: detectSeverity(comment)
+        });
+
+        // Store in inline comments map
+        if (!codeReview.inlineComments.has(filePath)) {
+          codeReview.inlineComments.set(filePath, new Map());
+        }
+        codeReview.inlineComments.get(filePath).set(lineNum, comment);
+      }
+    });
+
+    review.summary = reviewText;
+    codeReview.reviewHistory.push(review);
+
+    // Keep review history bounded
+    if (codeReview.reviewHistory.length > 10) {
+      codeReview.reviewHistory.shift();
+    }
+
+    return review;
+  } catch (e) {
+    log(`Code review failed: ${e.message}`);
+    return null;
+  }
+}
+
+// Detect severity of comment (error, warning, info)
+function detectSeverity(comment) {
+  const lowerComment = comment.toLowerCase();
+  if (lowerComment.includes('error') || lowerComment.includes('bug') ||
+      lowerComment.includes('critical') || lowerComment.includes('security')) {
+    return 'error';
+  } else if (lowerComment.includes('warning') || lowerComment.includes('potential') ||
+             lowerComment.includes('consider') || lowerComment.includes('performance')) {
+    return 'warning';
+  }
+  return 'info';
+}
+
+// Format and display code review results
+function displayCodeReview(review) {
+  if (!review) return;
+
+  console.log(`\n  ${C.cyan}━━━ Code Review (${review.id}) ━━━${C.reset}`);
+  console.log(`  ${C.dim}File: ${review.filePath}${C.reset}`);
+
+  // Display inline comments
+  if (review.comments.length > 0) {
+    console.log(`\n  ${C.bold}Inline Comments:${C.reset}`);
+    review.comments.forEach(comment => {
+      const icon = comment.severity === 'error' ? '❌' :
+                   comment.severity === 'warning' ? '⚠️' : '💡';
+      console.log(`    ${icon} ${C.dim}Line ${comment.line}:${C.reset} ${comment.comment}`);
+    });
+  }
+
+  // Display summary
+  console.log(`\n  ${C.bold}Review Summary:${C.reset}`);
+  const summaryLines = review.summary.split('\n').slice(0, 10);
+  summaryLines.forEach(line => {
+    if (line.trim()) console.log(`    ${line}`);
+  });
+
+  console.log(`\n  ${C.dim}Review saved. Use /reviews to see history.${C.reset}\n`);
+}
+
+// Extract code from Claude's output for review
+function extractCodeFromOutput(output) {
+  const codeBlocks = [];
+  const codeBlockPattern = /```(\w+)?\n([\s\S]*?)```/g;
+  let match;
+
+  while ((match = codeBlockPattern.exec(output)) !== null) {
+    codeBlocks.push({
+      language: match[1] || 'unknown',
+      code: match[2].trim()
+    });
+  }
+
+  return codeBlocks;
+}
+
 // ═══════════════════════════════════════════════════════════════
 //  TERMINAL UI
 // ═══════════════════════════════════════════════════════════════
@@ -281,8 +473,12 @@ class LoadingSpinner {
     // Clear line first
     process.stdout.write('\r' + ' '.repeat(80) + '\r');
 
+    // Only update spinner if output is visible (not in verbose mode)
     this.interval = setInterval(() => {
-      if (!this.active) return;
+      if (!this.active || verbose) {
+        // Stop updating if verbose mode is on
+        return;
+      }
 
       const elapsed = Math.round((Date.now() - this.startTime) / 1000);
       const frame = this.frames[this.frameIndex];
@@ -329,8 +525,9 @@ function printHeader() {
   console.log(`  ${C.dim}Log:${C.reset}      ${path.basename(logFile)}`);
   console.log('');
   console.log(`  ${C.dim}Talk to Knoxis naturally. He dispatches to Claude when needed.${C.reset}`);
-  console.log(`  ${C.dim}Commands: /status  /verbose  /diff  /log  /ai  /feedback  /exit${C.reset}`);
+  console.log(`  ${C.dim}Commands: /status  /verbose  /diff  /log  /ai  /feedback  /review  /exit${C.reset}`);
   console.log(`  ${C.dim}Quick feedback: 👍 or +1 (good), 👎 or -1 (needs improvement)${C.reset}`);
+  console.log(`  ${C.dim}Code review: /review [file] or /autoreview to toggle${C.reset}`);
   console.log('');
 }
 
@@ -574,6 +771,8 @@ Confidence: ${(insights.intent.confidence * 100).toFixed(0)}%\n\n`;
   }
 
   recordDecision(userInput, decision, outcome) {
+    const MAX_DECISION_HISTORY = 20;
+
     aiInsights.decisionHistory.push({
       timestamp: new Date().toISOString(),
       input: userInput.slice(0, 100),
@@ -581,8 +780,8 @@ Confidence: ${(insights.intent.confidence * 100).toFixed(0)}%\n\n`;
       outcome: outcome
     });
 
-    // Keep only last 20 decisions
-    if (aiInsights.decisionHistory.length > 20) {
+    // Keep only last N decisions for memory management
+    if (aiInsights.decisionHistory.length > MAX_DECISION_HISTORY) {
       aiInsights.decisionHistory.shift();
     }
   }
@@ -660,13 +859,15 @@ Confidence: ${(insights.intent.confidence * 100).toFixed(0)}%\n\n`;
       });
     }
 
-    // Keep feedback history bounded
-    if (aiInsights.feedbackHistory.length > 100) {
-      aiInsights.feedbackHistory.shift();
+    // Keep feedback history bounded for memory management
+    const MAX_FEEDBACK_HISTORY = 100;
+    if (aiInsights.feedbackHistory.length > MAX_FEEDBACK_HISTORY) {
+      // Remove oldest entries
+      aiInsights.feedbackHistory.splice(0, aiInsights.feedbackHistory.length - MAX_FEEDBACK_HISTORY);
     }
 
     // Save feedback data after processing
-    saveFeedbackData();
+    saveFeedbackData(); // Fire and forget for performance
 
     return {
       processed: true,
@@ -754,12 +955,25 @@ function detectProject() {
     }
   } catch (e) {}
 
-  // Git branch
+  // Git branch - use cached value or async check
   try {
-    const result = spawnSync('git', ['branch', '--show-current'], { cwd: WORKSPACE, stdio: 'pipe' });
-    if (result.status === 0) {
-      const branch = result.stdout.toString().trim();
-      if (branch) info.push(`Git branch: ${branch}`);
+    // For initial detection, still use sync but add caching
+    if (!aiInsights.contextCache.has('gitBranch')) {
+      const result = spawnSync('git', ['branch', '--show-current'], {
+        cwd: WORKSPACE,
+        stdio: 'pipe',
+        shell: false // Prevent shell injection
+      });
+      if (result.status === 0) {
+        const branch = result.stdout.toString().trim();
+        if (branch) {
+          aiInsights.contextCache.set('gitBranch', branch);
+          info.push(`Git branch: ${branch}`);
+        }
+      }
+    } else {
+      const cachedBranch = aiInsights.contextCache.get('gitBranch');
+      info.push(`Git branch: ${cachedBranch}`);
     }
   } catch (e) {}
 
@@ -866,8 +1080,10 @@ function callGroq(messages, projectContext) {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(payload)
-        }
+          'Content-Length': Buffer.byteLength(payload),
+          'Connection': 'keep-alive'
+        },
+        agent: url.protocol === 'https:' ? httpsAgent : httpAgent // Use keep-alive agent
       };
     } else {
       // Direct Groq API call (legacy / developer override)
@@ -878,8 +1094,10 @@ function callGroq(messages, projectContext) {
         headers: {
           'Content-Type': 'application/json',
           'Authorization': `Bearer ${GROQ_API_KEY}`,
-          'Content-Length': Buffer.byteLength(payload)
-        }
+          'Content-Length': Buffer.byteLength(payload),
+          'Connection': 'keep-alive'
+        },
+        agent: httpsAgent // Use keep-alive agent
       };
     }
 
@@ -1038,21 +1256,35 @@ function dispatchToClaude(prompt) {
 //  CONVERSATION MANAGEMENT
 // ═══════════════════════════════════════════════════════════════
 
-// Keep conversation history bounded. Always keep first 2 messages (greeting context)
-// and last 18 messages. Truncate long assistant messages.
+// Keep conversation history bounded with efficient memory management
+// Always keep first 2 messages (greeting context) and last 18 messages
 function trimHistory() {
   const MAX_MESSAGES = 24;
-  if (conversationHistory.length <= MAX_MESSAGES) return;
+  const MAX_MESSAGE_LENGTH = 5000; // Truncate individual messages too
+
+  if (conversationHistory.length <= MAX_MESSAGES) {
+    // Still truncate long messages even if under message limit
+    conversationHistory.forEach(msg => {
+      if (msg.content && msg.content.length > MAX_MESSAGE_LENGTH) {
+        msg.content = msg.content.substring(0, MAX_MESSAGE_LENGTH) + '... [truncated]';
+      }
+    });
+    return;
+  }
 
   const keep = 2; // greeting exchange
-  const tail = MAX_MESSAGES - keep;
-  const trimmed = [
-    ...conversationHistory.slice(0, keep),
-    { role: 'user', content: '[Earlier conversation trimmed for context. See dispatch summaries in system prompt for work done.]' },
-    ...conversationHistory.slice(-tail)
-  ];
-  conversationHistory.length = 0;
-  conversationHistory.push(...trimmed);
+  const tail = MAX_MESSAGES - keep - 1; // -1 for the trim notice
+
+  // Use splice for efficient in-place modification
+  const trimNotice = { role: 'user', content: '[Earlier conversation trimmed for context. See dispatch summaries in system prompt for work done.]' };
+  conversationHistory.splice(keep, conversationHistory.length - keep - tail, trimNotice);
+
+  // Truncate long messages
+  conversationHistory.forEach(msg => {
+    if (msg.content && msg.content.length > MAX_MESSAGE_LENGTH) {
+      msg.content = msg.content.substring(0, MAX_MESSAGE_LENGTH) + '... [truncated]';
+    }
+  });
 }
 
 // Truncate Claude output for Groq review (Groq doesn't need the full thing)
@@ -1069,13 +1301,13 @@ function truncateForReview(output, maxChars) {
 //  COMMAND HANDLERS
 // ═══════════════════════════════════════════════════════════════
 
-function handleCommand(input) {
+async function handleCommand(input) {
   const cmd = input.toLowerCase().trim();
 
   if (cmd === '/exit' || cmd === '/quit' || cmd === '/q') {
     // Save feedback data before exit
     if (aiInsights.feedbackHistory.length > 0) {
-      saveFeedbackData();
+      saveFeedbackData(); // Fire and forget on exit
       console.log(`  ${C.green}✓ AI learning saved${C.reset}`);
     }
     log('SESSION END (user exit)');
@@ -1108,18 +1340,37 @@ function handleCommand(input) {
 
   if (cmd === '/diff') {
     try {
-      const result = spawnSync('git', ['diff', '--stat'], { cwd: WORKSPACE, stdio: 'pipe' });
-      const output = result.stdout.toString().trim();
-      if (output) {
-        console.log(`\n  ${C.dim}Git changes in workspace:${C.reset}`);
-        output.split('\n').forEach(line => console.log(`  ${C.dim}  ${line}${C.reset}`));
-      } else {
-        console.log(`\n  ${C.dim}No uncommitted changes.${C.reset}`);
-      }
+      // Use spawn instead of spawnSync for better performance
+      const { spawn } = require('child_process');
+      const gitDiff = spawn('git', ['diff', '--stat'], {
+        cwd: WORKSPACE,
+        stdio: 'pipe',
+        shell: false // Prevent shell injection
+      });
+
+      let output = '';
+      gitDiff.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+
+      gitDiff.on('close', (code) => {
+        if (code === 0 && output.trim()) {
+          console.log(`\n  ${C.dim}Git changes in workspace:${C.reset}`);
+          output.trim().split('\n').forEach(line => console.log(`  ${C.dim}  ${line}${C.reset}`));
+        } else {
+          console.log(`\n  ${C.dim}No uncommitted changes.${C.reset}`);
+        }
+        console.log('');
+      });
+
+      gitDiff.on('error', () => {
+        console.log(`\n  ${C.dim}Not a git repository or git not available.${C.reset}`);
+        console.log('');
+      });
     } catch (e) {
-      console.log(`\n  ${C.dim}Not a git repository or git not available.${C.reset}`);
+      console.log(`\n  ${C.dim}Error running git diff.${C.reset}`);
+      console.log('');
     }
-    console.log('');
     return true;
   }
 
@@ -1205,6 +1456,70 @@ function handleCommand(input) {
     return true;
   }
 
+  // Code review commands
+  if (cmd === '/review') {
+    const args = input.split(' ').slice(1);
+
+    if (args.length === 0) {
+      // Review last Claude output if available
+      if (dispatchSummaries.length > 0) {
+        const lastOutput = dispatchSummaries[dispatchSummaries.length - 1];
+        const codeBlocks = extractCodeFromOutput(lastOutput);
+
+        if (codeBlocks.length > 0) {
+          console.log(`\n  ${C.cyan}Reviewing code from last Claude output...${C.reset}\n`);
+          for (const block of codeBlocks) {
+            const review = await reviewCode(block.code, `<inline-${block.language}>`, 1);
+            displayCodeReview(review);
+          }
+        } else {
+          console.log(`  ${C.yellow}No code found in last output. Use: /review [file]${C.reset}\n`);
+        }
+      } else {
+        console.log(`  ${C.yellow}No recent output to review. Use: /review [file]${C.reset}\n`);
+      }
+    } else {
+      // Review specific file
+      const filePath = path.resolve(WORKSPACE, args[0]);
+      try {
+        const fileContent = await fsPromises.readFile(filePath, 'utf8');
+        console.log(`\n  ${C.cyan}Reviewing ${path.basename(filePath)}...${C.reset}\n`);
+        const review = await reviewCode(fileContent, filePath, 1);
+        displayCodeReview(review);
+      } catch (e) {
+        console.log(`  ${C.red}Error reading file: ${e.message}${C.reset}\n`);
+      }
+    }
+    return true;
+  }
+
+  if (cmd === '/autoreview') {
+    codeReview.autoReviewEnabled = !codeReview.autoReviewEnabled;
+    const status = codeReview.autoReviewEnabled ? 'ENABLED' : 'DISABLED';
+    console.log(`\n  ${C.green}Auto-review ${status}${C.reset}`);
+    console.log(`  ${C.dim}Code will ${codeReview.autoReviewEnabled ? '' : 'not '}be automatically reviewed after Claude outputs.${C.reset}\n`);
+    return true;
+  }
+
+  if (cmd === '/reviews') {
+    if (codeReview.reviewHistory.length === 0) {
+      console.log(`\n  ${C.dim}No code reviews yet.${C.reset}\n`);
+    } else {
+      console.log(`\n  ${C.cyan}━━━ Code Review History ━━━${C.reset}`);
+      codeReview.reviewHistory.slice(-5).forEach(review => {
+        const time = new Date(review.timestamp).toLocaleTimeString();
+        const commentCount = review.comments.length;
+        const errorCount = review.comments.filter(c => c.severity === 'error').length;
+        const warningCount = review.comments.filter(c => c.severity === 'warning').length;
+
+        console.log(`  ${C.dim}${time}${C.reset} [${review.id}] ${review.filePath}`);
+        console.log(`    ${errorCount} errors, ${warningCount} warnings, ${commentCount} total comments`);
+      });
+      console.log('');
+    }
+    return true;
+  }
+
   return false;
 }
 
@@ -1213,6 +1528,20 @@ function handleCommand(input) {
 // ═══════════════════════════════════════════════════════════════
 
 let projectContext = '';
+let inputDebounceTimer = null;
+const INPUT_DEBOUNCE_MS = 100;
+
+// Debounced input handler
+function debouncedHandleUserInput(input, rl) {
+  if (inputDebounceTimer) {
+    clearTimeout(inputDebounceTimer);
+  }
+
+  inputDebounceTimer = setTimeout(() => {
+    inputDebounceTimer = null;
+    handleUserInput(input, rl);
+  }, INPUT_DEBOUNCE_MS);
+}
 
 async function handleUserInput(input, rl) {
   const trimmed = input.trim();
@@ -1269,7 +1598,7 @@ async function handleUserInput(input, rl) {
 
   // Handle slash commands
   if (trimmed.startsWith('/')) {
-    if (handleCommand(trimmed)) return;
+    if (await handleCommand(trimmed)) return;
     // Unknown command — pass through to Knoxis
   }
 
@@ -1337,6 +1666,20 @@ async function handleUserInput(input, rl) {
 
         printDivider(`Claude finished (${result.elapsed}s, ${result.lines} lines)`, C.green);
 
+        // Auto-review code if enabled
+        if (codeReview.autoReviewEnabled) {
+          const codeBlocks = extractCodeFromOutput(result.output);
+          if (codeBlocks.length > 0) {
+            console.log(`\n  ${C.cyan}Auto-reviewing code...${C.reset}`);
+            for (const block of codeBlocks) {
+              const review = await reviewCode(block.code, `<${block.language}>`, 1);
+              if (review && review.comments.length > 0) {
+                displayCodeReview(review);
+              }
+            }
+          }
+        }
+
         // Send output to Knoxis for review
         const reviewMessages = [
           ...conversationHistory,
@@ -1372,9 +1715,10 @@ async function handleUserInput(input, rl) {
           console.log('');
         }
 
-        // Track dispatch summary (short version for system prompt context)
+        // Track dispatch summary and full output for code review
         const shortSummary = review.message.split('\n')[0].slice(0, 150);
-        dispatchSummaries.push(shortSummary);
+        dispatchSummaries.push(result.output); // Store full output for review command
+        codeReview.lastReviewedCode = result.output; // Cache for quick access
 
         // Add review to history with AI suggestions
         conversationHistory.push({
@@ -1449,7 +1793,7 @@ async function main() {
   projectContext = detectProject();
 
   // Load feedback data from previous sessions
-  loadFeedbackData();
+  await loadFeedbackData();
 
   // Print header
   printHeader();
@@ -1487,7 +1831,7 @@ async function main() {
     } else {
       // Save feedback data before exit
       if (aiInsights.feedbackHistory.length > 0) {
-        saveFeedbackData();
+        saveFeedbackData(); // Fire and forget on exit
       }
       log('SESSION END (Ctrl+C)');
       console.log(`\n\n  ${C.dim}Session ended. ${claudeDispatches} dispatches to Claude.${C.reset}`);
@@ -1528,6 +1872,20 @@ async function main() {
         const result = await dispatchToClaude(enrichedPrompt);
         printDivider(`Claude finished (${result.elapsed}s, ${result.lines} lines)`, C.green);
 
+        // Auto-review code if enabled
+        if (codeReview.autoReviewEnabled) {
+          const codeBlocks = extractCodeFromOutput(result.output);
+          if (codeBlocks.length > 0) {
+            console.log(`\n  ${C.cyan}Auto-reviewing code...${C.reset}`);
+            for (const block of codeBlocks) {
+              const review = await reviewCode(block.code, `<${block.language}>`, 1);
+              if (review && review.comments.length > 0) {
+                displayCodeReview(review);
+              }
+            }
+          }
+        }
+
         const reviewMessages = [
           ...conversationHistory,
           {
@@ -1540,7 +1898,8 @@ async function main() {
         const review = await callGroq(reviewMessages, projectContext);
         spinner.stop();
         printKnoxis(review.message);
-        dispatchSummaries.push(review.message.split('\n')[0].slice(0, 150));
+        dispatchSummaries.push(result.output); // Store full output for review command
+        codeReview.lastReviewedCode = result.output; // Cache for quick access
         conversationHistory.push({
           role: 'assistant',
           content: JSON.stringify({ action: 'respond', message: review.message })

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "knoxis-collab",
-  "version": "1.3.0",
-  "description": "AI-enhanced collaborative programming with feedback learning — User + Knoxis + Claude Code with adaptive intelligence",
+  "version": "1.4.0",
+  "description": "AI-enhanced collaborative programming with real-time code review and feedback learning — User + Knoxis + Claude Code with adaptive intelligence",
   "main": "knoxis-collab.js",
   "bin": {
     "knoxis-collab": "./knoxis-collab.js"