jay-code/src/models/claude-client.ts

Streamlined AI CLI orchestration engine with mathematical rigor and enterprise-grade reliability

/**
 * Claude API Client for Jay-Code fallback system
 * Based on existing claude-flow integration patterns
 */
import https from 'https';

export interface ClaudeConfig {
  apiKey: string;
  model: string;
  maxTokens?: number;
  temperature?: number;
  timeout?: number;
}

export interface ClaudeResponse {
  content: string;
  usage: {
    input_tokens: number;
    output_tokens: number;
  };
  stop_reason: string;
}

export class ClaudeClient {
  private config: ClaudeConfig;

  constructor(config: ClaudeConfig) {
    this.config = {
      maxTokens: 4000,
      temperature: 0.3,
      timeout: 60000,
      ...config
    };
  }

  async generateCode(prompt: string, context?: any): Promise<string> {
    const requestBody = {
      model: this.config.model,
      max_tokens: this.config.maxTokens,
      temperature: this.config.temperature,
      messages: [
        {
          role: 'user',
          content: prompt
        }
      ]
    };

    return new Promise((resolve, reject) => {
      const data = JSON.stringify(requestBody);
      
      const options = {
        hostname: 'api.anthropic.com',
        port: 443,
        path: '/v1/messages',
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Content-Length': Buffer.byteLength(data),
          'x-api-key': this.config.apiKey,
          'anthropic-version': '2023-06-01'
        },
        timeout: this.config.timeout
      };

      const req = https.request(options, (res) => {
        let responseData = '';

        res.on('data', (chunk) => {
          responseData += chunk;
        });

        res.on('end', () => {
          try {
            if (res.statusCode !== 200) {
              reject(new Error(`Claude API error: ${res.statusCode} ${responseData}`));
              return;
            }

            const parsed = JSON.parse(responseData);
            
            if (parsed.content && parsed.content[0] && parsed.content[0].text) {
              resolve(parsed.content[0].text);
            } else {
              reject(new Error('Unexpected Claude API response format'));
            }
          } catch (error) {
            reject(new Error(`Failed to parse Claude response: ${error.message}`));
          }
        });
      });

      req.on('error', (error) => {
        reject(new Error(`Claude API request failed: ${error.message}`));
      });

      req.on('timeout', () => {
        req.destroy();
        reject(new Error('Claude API request timeout'));
      });

      req.write(data);
      req.end();
    });
  }

  async healthCheck(): Promise<boolean> {
    try {
      await this.generateCode('Test connection', { maxTokens: 10 });
      return true;
    } catch (error) {
      return false;
    }
  }
}