knoxis-collab 1.4.1 → 1.5.0

package/knoxis-collab.js

@@ -112,63 +112,23 @@ 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 || '';
 
-// Resolve Claude binary — check every reasonable location
-const IS_WIN = process.platform === 'win32';
-
-function existsAny(basePath) {
-  // On Windows, .bin has claude.cmd / claude.ps1 rather than a bare 'claude'
-  const candidates = IS_WIN
-    ? [basePath + '.cmd', basePath + '.ps1', basePath]
-    : [basePath];
-  for (const c of candidates) {
-    if (fs.existsSync(c)) return c;
-  }
-  return null;
-}
-
-function resolveClaudeBin() {
-  // 1. Local node_modules (when installed as npm package)
-  const localBin = existsAny(path.join(__dirname, 'node_modules', '.bin', 'claude'));
-  if (localBin) return localBin;
-
-  // 2. Parent node_modules (when this is a dep of another package)
-  const parentBin = existsAny(path.join(__dirname, '..', '.bin', 'claude'));
-  if (parentBin) return parentBin;
+// Claude Agent SDK — loaded via dynamic import (ESM package in CommonJS context)
+// The SDK provides programmatic access to Claude Code's capabilities without CLI spawning.
+let claudeAgentSdk = null;
 
-  // 3. Global npm prefix bin (same dir where knoxis-collab bin lands)
+async function loadClaudeAgentSdk() {
+  if (claudeAgentSdk) return claudeAgentSdk;
   try {
-    const { status, stdout } = spawnSync('npm', ['prefix', '-g'], { stdio: 'pipe', shell: IS_WIN });
-    if (status === 0) {
-      const prefix = stdout.toString().trim();
-      // npm global bins: prefix/bin on unix, prefix on windows
-      const globalBin = existsAny(path.join(prefix, IS_WIN ? '' : 'bin', 'claude'));
-      if (globalBin) return globalBin;
-    }
-  } catch (e) {}
-
-  // 4. Resolve via require (finds the package even if bin symlink is missing)
-  try {
-    const claudePkg = path.dirname(require.resolve('@anthropic-ai/claude-code/package.json'));
-    const pkg = JSON.parse(fs.readFileSync(path.join(claudePkg, 'package.json'), 'utf8'));
-    const binEntry = typeof pkg.bin === 'string' ? pkg.bin : (pkg.bin && pkg.bin.claude);
-    if (binEntry) {
-      const resolved = path.join(claudePkg, binEntry);
-      if (fs.existsSync(resolved)) return resolved;
-    }
-  } catch (e) {}
-
-  // 5. Fall back to global PATH
-  try {
-    const cmd = IS_WIN ? 'where' : 'which';
-    const { status, stdout } = spawnSync(cmd, ['claude'], { stdio: 'pipe', shell: IS_WIN });
-    if (status === 0 && stdout.toString().trim()) return stdout.toString().trim().split('\n')[0];
-  } catch (e) {}
-
-  return null;
+    claudeAgentSdk = await import('@anthropic-ai/claude-agent-sdk');
+    return claudeAgentSdk;
+  } catch (e) {
+    throw new Error(
+      `Failed to load @anthropic-ai/claude-agent-sdk: ${e.message}\n` +
+      `  Install it with: npm install @anthropic-ai/claude-agent-sdk`
+    );
+  }
 }
 
-const CLAUDE_BIN = resolveClaudeBin();
-
 // ═══════════════════════════════════════════════════════════════
 //  STATE
 // ═══════════════════════════════════════════════════════════════
@@ -177,7 +137,6 @@ let claudeSessionId = null;
 let claudeDispatches = 0;
 let verbose = cliArgs.verbose;
 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
@@ -521,7 +480,7 @@ function printHeader() {
   console.log(`  ${C.dim}Dir:${C.reset}      ${WORKSPACE}`);
   const groqMode = (BACKEND_URL && USER_ID) ? `via backend` : 'direct API';
   console.log(`  ${C.dim}Knoxis:${C.reset}   Groq (${GROQ_MODEL}, ${groqMode})`);
-  console.log(`  ${C.dim}Claude:${C.reset}   Claude Code (session-persistent)`);
+  console.log(`  ${C.dim}Claude:${C.reset}   Claude Agent SDK (session-persistent)`);
   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}`);
@@ -1156,103 +1115,180 @@ function callGroq(messages, projectContext) {
 }
 
 // ═══════════════════════════════════════════════════════════════
-//  CLAUDE CODE DISPATCH
+//  CLAUDE CODE DISPATCH (via Agent SDK)
 // ═══════════════════════════════════════════════════════════════
 
-function checkClaudeInstalled() {
-  return CLAUDE_BIN !== null;
+async function checkClaudeInstalled() {
+  try {
+    await loadClaudeAgentSdk();
+    return true;
+  } catch (e) {
+    return false;
+  }
 }
 
-function dispatchToClaude(prompt) {
-  return new Promise((resolve, reject) => {
-    claudeDispatches++;
-    isClaudeRunning = true;
+// AbortController for the current dispatch — allows Ctrl+C cancellation
+let activeAbortController = null;
+
+async function dispatchToClaude(prompt) {
+  const sdk = await loadClaudeAgentSdk();
+  claudeDispatches++;
+  isClaudeRunning = true;
+
+  const startTime = Date.now();
+  let outputLines = 0;
+  let output = '';
+  let resultData = null;
+
+  log(`DISPATCH #${claudeDispatches}:\n${prompt}`);
+
+  // Build SDK options
+  const queryOptions = {
+    cwd: WORKSPACE,
+    permissionMode: 'bypassPermissions',
+    persistSession: true,
+    env: {
+      ...process.env,
+      CLAUDE_AGENT_SDK_CLIENT_APP: `knoxis-collab/1.5.0`
+    },
+  };
 
-    const args = ['-p', '--dangerously-skip-permissions'];
-    if (claudeSessionId) {
-      args.push('--resume', claudeSessionId);
-    } else {
-      claudeSessionId = SESSION_ID;
-      args.push('--session-id', claudeSessionId);
-    }
+  // Session management: resume existing or start new
+  if (claudeSessionId) {
+    queryOptions.resume = claudeSessionId;
+  } else {
+    queryOptions.sessionId = SESSION_ID;
+  }
 
-    log(`DISPATCH #${claudeDispatches}:\n${prompt}`);
+  // Create abort controller for cancellation support
+  activeAbortController = new AbortController();
+  queryOptions.abortController = activeAbortController;
 
-    // On Windows, spawn with shell requires a single command string to avoid DEP0190
-    const spawnCmd = IS_WIN ? `"${CLAUDE_BIN}" ${args.join(' ')}` : CLAUDE_BIN;
-    const spawnArgs = IS_WIN ? [] : args;
+  // Start spinner
+  if (!verbose) {
+    spinner.start('Claude is processing');
+  }
 
-    const proc = spawn(spawnCmd, spawnArgs, {
-      cwd: WORKSPACE,
-      env: { ...process.env },
-      stdio: ['pipe', 'pipe', 'pipe'],
-      shell: IS_WIN
-    });
+  try {
+    const conversation = sdk.query({ prompt, options: queryOptions });
 
-    activeClaudeProc = proc;
-    let stdout = '';
-    let stderr = '';
-    let outputLines = 0;
-    const startTime = Date.now();
+    for await (const message of conversation) {
+      // Capture session ID from first message
+      if (!claudeSessionId && message.session_id) {
+        claudeSessionId = message.session_id;
+      }
 
-    // Start spinner when Claude begins processing
-    if (!verbose) {
-      spinner.start('Claude is processing');
-    }
+      switch (message.type) {
+        case 'assistant': {
+          // Extract text content from the assistant message
+          const textBlocks = (message.message.content || [])
+            .filter(block => block.type === 'text')
+            .map(block => block.text);
+
+          if (textBlocks.length > 0) {
+            const text = textBlocks.join('\n');
+            output += text + '\n';
+            const newLines = text.split('\n').filter(l => l.trim()).length;
+            outputLines += newLines;
+            printClaudeLine(text);
+
+            if (!verbose) {
+              spinner.update(`Claude is processing (${outputLines} lines)`);
+            }
+          }
+          break;
+        }
 
-    proc.stdout.on('data', (chunk) => {
-      const text = chunk.toString();
-      stdout += text;
-      outputLines += text.split('\n').filter(l => l.trim()).length;
-      printClaudeLine(text);
-      if (!verbose) {
-        // Update spinner with progress info
-        spinner.update(`Claude is processing (${outputLines} lines)`);
-      }
-    });
+        case 'tool_use_summary': {
+          // Show what tool Claude just used (e.g., "Read src/main.js")
+          const summary = message.summary || '';
+          if (summary) {
+            printClaudeLine(`[Tool] ${summary}`);
+            if (!verbose) {
+              spinner.update(`Claude: ${summary.slice(0, 50)}`);
+            }
+          }
+          break;
+        }
 
-    proc.stderr.on('data', (chunk) => {
-      const text = chunk.toString();
-      if (!text.includes('Debug:') && !text.includes('trace')) {
-        stderr += text;
-      }
-    });
+        case 'tool_progress': {
+          // Update spinner with tool progress (e.g., long-running Bash)
+          if (!verbose) {
+            const elapsed = Math.round(message.elapsed_time_seconds || 0);
+            spinner.update(`Claude: ${message.tool_name} (${elapsed}s)`);
+          }
+          break;
+        }
 
-    proc.on('close', (code) => {
-      isClaudeRunning = false;
-      activeClaudeProc = null;
+        case 'result': {
+          resultData = message;
+          if (message.subtype === 'success') {
+            // The result field contains Claude's final text summary
+            if (message.result) {
+              output += message.result + '\n';
+              outputLines += message.result.split('\n').filter(l => l.trim()).length;
+            }
+          }
+          break;
+        }
 
-      // Stop spinner
-      if (!verbose) {
-        spinner.stop();
+        case 'system': {
+          // Log system messages for debugging
+          if (message.subtype === 'api_retry') {
+            log(`SDK API RETRY: attempt ${message.attempt}/${message.max_retries}`);
+            if (!verbose) {
+              spinner.update(`Claude: retrying API call (${message.attempt}/${message.max_retries})`);
+            }
+          }
+          break;
+        }
+
+        // Ignore other message types (stream_event, user, etc.)
+        default:
+          break;
       }
-      clearClaudeStatus();
+    }
 
-      const elapsed = Math.round((Date.now() - startTime) / 1000);
-      log(`CLAUDE DONE (exit ${code}, ${elapsed}s, ${outputLines} lines):\n${stdout.slice(0, 2000)}`);
+    isClaudeRunning = false;
+    activeAbortController = null;
 
-      if (code === 0 || stdout.length > 0) {
-        resolve({ output: stdout.trim(), exitCode: code || 0, elapsed, lines: outputLines });
-      } else {
-        reject(new Error(`Claude exited with code ${code}${stderr ? ': ' + stderr.slice(0, 500) : ''}`));
-      }
-    });
+    // Stop spinner
+    if (!verbose) {
+      spinner.stop();
+    }
+    clearClaudeStatus();
 
-    proc.on('error', (err) => {
-      isClaudeRunning = false;
-      activeClaudeProc = null;
+    const elapsed = Math.round((Date.now() - startTime) / 1000);
+    const exitCode = (resultData && resultData.subtype === 'success') ? 0 : 1;
 
-      // Stop spinner on error
-      if (!verbose) {
-        spinner.stop();
-      }
-      clearClaudeStatus();
-      reject(err);
-    });
+    log(`CLAUDE DONE (exit ${exitCode}, ${elapsed}s, ${outputLines} lines):\n${output.slice(0, 2000)}`);
 
-    proc.stdin.write(prompt);
-    proc.stdin.end();
-  });
+    if (resultData && resultData.subtype !== 'success') {
+      const errMsg = resultData.error || 'Claude returned an error result';
+      throw new Error(errMsg);
+    }
+
+    return { output: output.trim(), exitCode, elapsed, lines: outputLines };
+
+  } catch (err) {
+    isClaudeRunning = false;
+    activeAbortController = null;
+
+    // Stop spinner on error
+    if (!verbose) {
+      spinner.stop();
+    }
+    clearClaudeStatus();
+
+    // Differentiate abort from real errors
+    if (err.name === 'AbortError' || activeAbortController?.signal?.aborted) {
+      log(`CLAUDE ABORTED after ${Math.round((Date.now() - startTime) / 1000)}s`);
+      throw new Error('Claude dispatch was cancelled');
+    }
+
+    log(`CLAUDE ERROR: ${err.message}`);
+    throw err;
+  }
 }
 
 // ═══════════════════════════════════════════════════════════════
@@ -1825,10 +1861,10 @@ async function main() {
     process.exit(1);
   }
 
-  if (!checkClaudeInstalled()) {
-    console.error(`\n  ${C.red}Error: 'claude' CLI not found.${C.reset}`);
-    console.error(`  It should be bundled with this package. Try: npm install`);
-    console.error(`  Or install globally: npm install -g @anthropic-ai/claude-code\n`);
+  if (!(await checkClaudeInstalled())) {
+    console.error(`\n  ${C.red}Error: @anthropic-ai/claude-agent-sdk not found.${C.reset}`);
+    console.error(`  Install it with: npm install @anthropic-ai/claude-agent-sdk`);
+    console.error(`  Or reinstall this package: npm install knoxis-collab\n`);
     process.exit(1);
   }
 
@@ -1865,17 +1901,14 @@ async function main() {
     prompt: `  ${C.green}You:${C.reset} `,
   });
 
-  // Handle Ctrl+C — kill Claude if running, otherwise exit
+  // Handle Ctrl+C — abort Claude SDK query if running, otherwise exit
   process.on('SIGINT', () => {
     // Stop any active spinner
     spinner.stop();
 
-    if (isClaudeRunning && activeClaudeProc) {
+    if (isClaudeRunning && activeAbortController) {
       console.log(`\n\n  ${C.yellow}Cancelling Claude...${C.reset}\n`);
-      try { activeClaudeProc.kill('SIGTERM'); } catch (e) {}
-      setTimeout(() => {
-        try { if (activeClaudeProc) activeClaudeProc.kill('SIGKILL'); } catch (e) {}
-      }, 3000);
+      activeAbortController.abort();
     } else {
       // Save feedback data before exit
       if (aiInsights.feedbackHistory.length > 0) {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "knoxis-collab",
-  "version": "1.4.1",
+  "version": "1.5.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"
   },
   "dependencies": {
-    "@anthropic-ai/claude-code": "^1.0.0"
+    "@anthropic-ai/claude-agent-sdk": "^0.2.108"
   },
   "keywords": [
     "knoxis",