@zibby/core 0.1.0

package/src/framework/agents/claude-strategy.js

@@ -0,0 +1,278 @@
+/**
+ * Claude Agent Strategy - Uses @anthropic-ai/claude-agent-sdk
+ * Provides full agent with Read, Write, Bash, Grep, Glob tools + MCP support
+ */
+
+import { AgentStrategy } from './base.js';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { logger } from '../../utils/logger.js';
+import { timeline } from '../../utils/timeline.js';
+import { DEFAULT_MODELS, CLAUDE_MODEL_MAP } from '../../constants.js';
+import { getSkill } from '../skill-registry.js';
+
+export class ClaudeAgentStrategy extends AgentStrategy {
+  constructor() {
+    super(
+      'claude',
+      'Claude Agent SDK',
+      50 // Lower priority - fallback option
+    );
+  }
+
+  canHandle(_context) {
+    const hasKey = !!process.env.ANTHROPIC_API_KEY;
+    if (!hasKey) {
+      logger.debug('ClaudeAgentStrategy: ANTHROPIC_API_KEY not set');
+    }
+    return hasKey;
+  }
+
+  async invoke(prompt, options = {}) {
+    const {
+      model: requestedModel,
+      workspace = process.cwd(),
+      schema = null,
+      images: _images = [],
+      skills = null,
+      sessionPath = null,
+      timeout: _timeout,
+      config: _config = {}
+    } = options;
+
+    // Model resolution
+    let userModel = requestedModel;
+    if (!userModel || userModel === 'auto') {
+      logger.debug(`Model is '${userModel || 'undefined'}', using default: ${DEFAULT_MODELS.CLAUDE}`);
+      userModel = DEFAULT_MODELS.CLAUDE;
+    }
+    
+    const model = CLAUDE_MODEL_MAP[userModel] || userModel;
+    if (CLAUDE_MODEL_MAP[userModel] && userModel !== model) {
+      logger.debug(`Mapped model: ${userModel} → ${model}`);
+    }
+    
+    logger.debug(`Invoking Claude Agent SDK with model: ${model}, skills: ${JSON.stringify(skills)}`);
+
+    const { allowedTools, mcpServers } = this._resolveSkills(skills, { sessionPath, workspace });
+
+    try {
+      const queryOptions = {
+        cwd: workspace,
+        allowedTools,
+        permissionMode: 'bypassPermissions',
+        model,
+        ...(Object.keys(mcpServers).length > 0 && { mcpServers }),
+      };
+      
+      if (schema) {
+        const isZod = typeof schema.parse === 'function';
+        const jsonSchema = isZod ? zodToJsonSchema(schema, { target: 'openApi3' }) : schema;
+        queryOptions.outputFormat = { type: 'json_schema', schema: jsonSchema };
+        logger.debug('Structured output enforced via SDK outputFormat');
+      }
+
+      logger.debug(`Agent SDK options: ${JSON.stringify({ 
+        cwd: queryOptions.cwd,
+        toolCount: allowedTools.length,
+        permissionMode: queryOptions.permissionMode,
+        model: queryOptions.model,
+        hasOutputFormat: !!queryOptions.outputFormat
+      })}`);
+
+      // Collect all messages from agent
+      let finalText = '';
+      let toolCallCount = 0;
+      const allMessages = [];
+      
+      logger.debug('Starting Claude Agent SDK query stream');
+      
+      let queryIterator;
+      try {
+        queryIterator = query({ prompt, options: queryOptions });
+      } catch (initError) {
+        logger.error(`Failed to initialize Claude Agent SDK: ${initError.message}`);
+        throw initError;
+      }
+      
+      let lastMsgSig = null;
+      let repeatCount = 0;
+      const MAX_REPEATS = 3;
+
+      try {
+        for await (const message of queryIterator) {
+          allMessages.push(message);
+
+          // Bail on explicit error events
+          if (message.type === 'error' || message.error) {
+            const errMsg = message.error?.message || message.error || message.message || 'Unknown API error';
+            throw new Error(typeof errMsg === 'string' ? errMsg : JSON.stringify(errMsg));
+          }
+
+          // Detect infinite loops: if the same message repeats N times, the API is stuck
+          const sig = JSON.stringify(message.message?.content || message.text || '').slice(0, 200);
+          if (sig === lastMsgSig) {
+            repeatCount++;
+            if (repeatCount >= MAX_REPEATS) {
+              const preview = (message.message?.content?.[0]?.text || message.text || 'unknown').slice(0, 100);
+              throw new Error(`API stuck in loop (${repeatCount}x repeated): ${preview}`);
+            }
+          } else {
+            lastMsgSig = sig;
+            repeatCount = 1;
+          }
+        
+          // AssistantMessage: Claude's thinking and tool calls
+          if (message.type === 'assistant' || message.constructor?.name === 'AssistantMessage') {
+            // Agent SDK wraps content in message.message.content (not message.content!)
+            const content = message.message?.content || message.content || [];
+            for (const block of content) {
+              if (block.type === 'thinking' && block.thinking) {
+                console.log(`${block.thinking.substring(0, 200)}${block.thinking.length > 200 ? '...' : ''}`);
+              } else if (block.type === 'text' && block.text) {
+                finalText += block.text;
+                if (block.text.length < 500) {
+                  console.log(`${block.text}`);
+                } else {
+                  console.log(`${block.text.substring(0, 200)}... (${block.text.length} chars)`);
+                }
+              } else if (block.type === 'tool_use') {
+                toolCallCount++;
+                const isMemTool = block.name.includes('memory');
+                if (isMemTool) {
+                  timeline.stepMemory(`Tool: ${block.name}`);
+                } else {
+                  timeline.stepTool(`Tool: ${block.name}`);
+                }
+                const inputPreview = JSON.stringify(block.input).substring(0, 100);
+                console.log(`  Input: ${inputPreview}${JSON.stringify(block.input).length > 100 ? '...' : ''}`);
+              }
+            }
+          }
+          // ToolResultMessage: Show tool execution results (silent, no prefix)
+          else if (message.type === 'user' && message.tool_use_result) {
+            // Tool results are silent - no output
+          }
+          // ResultMessage: final outcome
+          else if (message.type === 'result' || message.constructor?.name === 'ResultMessage') {
+            timeline.step(`Agent completed (${toolCallCount} tool calls)`);
+            logger.debug(`Agent completed (${toolCallCount} tool calls)`);
+            
+            const resultText = message.result || message.text || message.content || finalText;
+            
+            if (schema) {
+              // Priority 1: SDK native structured_output
+              if (message.structured_output) {
+                logger.debug('Using SDK native structured_output');
+                const isZod = typeof schema.parse === 'function';
+                const validated = isZod ? schema.parse(message.structured_output) : message.structured_output;
+                return { raw: resultText, structured: validated };
+              }
+              // Priority 2: Extract JSON from result text
+              if (resultText) {
+                const extracted = this._extractJson(resultText, schema);
+                if (extracted) {
+                  return { raw: resultText, structured: extracted };
+                }
+              }
+              logger.warn(`Could not extract structured output — returning raw text (${(resultText || '').length} chars)`);
+            }
+            
+            return resultText || '';
+          }
+      }
+      
+        logger.warn(`Agent SDK ended without result. Collected ${allMessages.length} messages`);
+        if (finalText.length > 0) {
+          logger.debug('Returning accumulated text from messages');
+          return finalText;
+        }
+
+        throw new Error('Claude Agent SDK query ended without result');
+      } catch (streamError) {
+        logger.error(`Error during query stream: ${streamError.message}`);
+        throw streamError;
+      }
+    } catch (error) {
+      logger.error('Claude Agent SDK call failed', { error: error.message });
+      throw error;
+    }
+  }
+
+  _resolveSkills(skills, resolveOpts) {
+    if (skills === null) {
+      logger.debug('No skills — pure LLM mode');
+      return { allowedTools: [], mcpServers: {} };
+    }
+
+    if (!Array.isArray(skills) || skills.length === 0) {
+      logger.debug('Default IDE skills for code generation');
+      return { allowedTools: ['Read', 'Write', 'Bash', 'Grep', 'Glob'], mcpServers: {} };
+    }
+
+    const allowedTools = [];
+    const mcpServers = {};
+
+    for (const skillId of skills) {
+      const skill = getSkill(skillId);
+      if (!skill) { logger.warn(`Unknown skill "${skillId}" — skipping`); continue; }
+      if (skill.allowedTools) allowedTools.push(...skill.allowedTools);
+      if (typeof skill.resolve === 'function') {
+        const resolved = skill.resolve(resolveOpts);
+        if (resolved) {
+          mcpServers[skill.serverName] = resolved;
+          logger.debug(`MCP: ${skill.serverName} → ${resolved.command} ${resolved.args[0]}`);
+        }
+      }
+    }
+
+    return { allowedTools, mcpServers };
+  }
+
+  _extractJson(text, schema) {
+    const strategies = [
+      () => {
+        if (text.includes('===JSON_START===')) {
+          const start = text.indexOf('===JSON_START===') + '===JSON_START==='.length;
+          const end = text.indexOf('===JSON_END===');
+          return text.substring(start, end).trim();
+        }
+      },
+      () => {
+        const match = text.match(/```json\s*\n([\s\S]*?)\n```/);
+        return match?.[1]?.trim();
+      },
+      () => {
+        if (!text.startsWith('{')) {
+          const match = text.match(/```\s*\n([\s\S]*?)\n```/);
+          return match?.[1]?.trim();
+        }
+      },
+      () => text.trim(),
+      () => {
+        const firstBrace = text.indexOf('{');
+        const lastBrace = text.lastIndexOf('}');
+        if (firstBrace !== -1 && lastBrace > firstBrace) {
+          return text.substring(firstBrace, lastBrace + 1);
+        }
+      }
+    ];
+
+    for (const extract of strategies) {
+      try {
+        const candidate = extract();
+        if (!candidate) continue;
+        const parsed = JSON.parse(candidate);
+        if (typeof parsed !== 'object' || parsed === null) continue;
+        const isZod = typeof schema.parse === 'function';
+        if (isZod) {
+          return schema.parse(parsed);
+        }
+        return parsed;
+      } catch {
+        // try next strategy
+      }
+    }
+    return null;
+  }
+}