@stackmemoryai/stackmemory 0.3.8 → 0.3.9

package/dist/core/execution/parallel-executor.js

@@ -0,0 +1,254 @@
+import { EventEmitter } from "events";
+import { logger } from "../monitoring/logger.js";
+class ParallelExecutor extends EventEmitter {
+  maxConcurrency;
+  queueSize;
+  defaultTimeout;
+  defaultRetries;
+  rateLimitPerMinute;
+  activeCount = 0;
+  queue = [];
+  rateLimitTokens;
+  lastRateLimitReset;
+  // Metrics
+  totalExecuted = 0;
+  totalSucceeded = 0;
+  totalFailed = 0;
+  totalDuration = 0;
+  constructor(maxConcurrency = 5, options = {}) {
+    super();
+    this.maxConcurrency = maxConcurrency;
+    this.queueSize = options.queueSize || 100;
+    this.defaultTimeout = options.defaultTimeout || 3e5;
+    this.defaultRetries = options.defaultRetries || 3;
+    this.rateLimitPerMinute = options.rateLimitPerMinute || 60;
+    this.rateLimitTokens = this.rateLimitPerMinute;
+    this.lastRateLimitReset = Date.now();
+    logger.info("Parallel Executor initialized", {
+      maxConcurrency,
+      queueSize: this.queueSize,
+      rateLimitPerMinute: this.rateLimitPerMinute
+    });
+  }
+  /**
+   * Execute multiple tasks in parallel
+   */
+  async executeParallel(items, executor, options) {
+    const results = [];
+    const batchSize = options?.batchSize || this.maxConcurrency;
+    const delayBetweenBatches = options?.delayBetweenBatches || 0;
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      const batchPromises = batch.map(
+        (item, index) => this.executeWithTracking(
+          `parallel-${i + index}`,
+          () => executor(item, i + index)
+        )
+      );
+      const batchResults = await Promise.allSettled(batchPromises);
+      batchResults.forEach((result, index) => {
+        if (result.status === "fulfilled") {
+          results.push(result.value);
+        } else {
+          results.push({
+            taskId: `parallel-${i + index}`,
+            success: false,
+            error: result.reason,
+            duration: 0,
+            attempts: 1
+          });
+        }
+      });
+      if (delayBetweenBatches > 0 && i + batchSize < items.length) {
+        await this.delay(delayBetweenBatches);
+      }
+      logger.debug("Batch completed", {
+        batchNumber: Math.floor(i / batchSize) + 1,
+        totalBatches: Math.ceil(items.length / batchSize),
+        successRate: results.filter((r) => r.success).length / results.length
+      });
+    }
+    return results;
+  }
+  /**
+   * Execute a single task with tracking and retries
+   */
+  async executeWithTracking(taskId, executor, options) {
+    const timeout = options?.timeout || this.defaultTimeout;
+    const maxRetries = options?.retries || this.defaultRetries;
+    let attempts = 0;
+    let lastError;
+    const startTime = Date.now();
+    while (attempts < maxRetries) {
+      attempts++;
+      try {
+        await this.checkRateLimit();
+        await this.waitForSlot();
+        this.activeCount++;
+        this.emit("task-start", { taskId, attempt: attempts });
+        const result = await this.executeWithTimeout(executor, timeout);
+        this.totalSucceeded++;
+        this.emit("task-success", { taskId, attempts });
+        return {
+          taskId,
+          success: true,
+          result,
+          duration: Date.now() - startTime,
+          attempts
+        };
+      } catch (error) {
+        lastError = error;
+        logger.warn(`Task failed (attempt ${attempts}/${maxRetries})`, {
+          taskId,
+          error: lastError.message
+        });
+        this.emit("task-retry", { taskId, attempt: attempts, error: lastError });
+        if (attempts < maxRetries) {
+          await this.delay(Math.pow(2, attempts) * 1e3);
+        }
+      } finally {
+        this.activeCount--;
+        this.totalExecuted++;
+        this.totalDuration += Date.now() - startTime;
+      }
+    }
+    this.totalFailed++;
+    this.emit("task-failed", { taskId, attempts, error: lastError });
+    return {
+      taskId,
+      success: false,
+      error: lastError,
+      duration: Date.now() - startTime,
+      attempts
+    };
+  }
+  /**
+   * Execute task with timeout
+   */
+  async executeWithTimeout(executor, timeout) {
+    return Promise.race([
+      executor(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Task timeout")), timeout)
+      )
+    ]);
+  }
+  /**
+   * Check and enforce rate limiting
+   */
+  async checkRateLimit() {
+    const now = Date.now();
+    const timeSinceReset = now - this.lastRateLimitReset;
+    if (timeSinceReset >= 6e4) {
+      this.rateLimitTokens = this.rateLimitPerMinute;
+      this.lastRateLimitReset = now;
+    }
+    if (this.rateLimitTokens <= 0) {
+      const waitTime = 6e4 - timeSinceReset;
+      logger.debug(`Rate limit reached, waiting ${waitTime}ms`);
+      await this.delay(waitTime);
+      this.rateLimitTokens = this.rateLimitPerMinute;
+      this.lastRateLimitReset = Date.now();
+    }
+    this.rateLimitTokens--;
+  }
+  /**
+   * Wait for an available execution slot
+   */
+  async waitForSlot() {
+    while (this.activeCount >= this.maxConcurrency) {
+      await this.delay(100);
+    }
+  }
+  /**
+   * Queue a task for execution
+   */
+  async queueTask(task) {
+    if (this.queue.length >= this.queueSize) {
+      throw new Error("Execution queue is full");
+    }
+    return new Promise((resolve) => {
+      this.queue.push({
+        ...task,
+        execute: async () => {
+          const result = await task.execute();
+          resolve({
+            taskId: task.id,
+            success: true,
+            result,
+            duration: 0,
+            attempts: 1
+          });
+          return result;
+        }
+      });
+      this.processQueue();
+    });
+  }
+  /**
+   * Process queued tasks
+   */
+  async processQueue() {
+    if (this.activeCount >= this.maxConcurrency || this.queue.length === 0) {
+      return;
+    }
+    this.queue.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    const task = this.queue.shift();
+    if (task) {
+      this.executeWithTracking(task.id, task.execute, {
+        timeout: task.timeout,
+        retries: task.retries
+      }).then(() => {
+        this.processQueue();
+      });
+    }
+  }
+  /**
+   * Utility delay function
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get execution metrics
+   */
+  getMetrics() {
+    return {
+      activeCount: this.activeCount,
+      queueLength: this.queue.length,
+      totalExecuted: this.totalExecuted,
+      totalSucceeded: this.totalSucceeded,
+      totalFailed: this.totalFailed,
+      successRate: this.totalExecuted > 0 ? this.totalSucceeded / this.totalExecuted : 0,
+      averageDuration: this.totalExecuted > 0 ? this.totalDuration / this.totalExecuted : 0,
+      rateLimitTokens: this.rateLimitTokens
+    };
+  }
+  /**
+   * Reset all metrics
+   */
+  resetMetrics() {
+    this.totalExecuted = 0;
+    this.totalSucceeded = 0;
+    this.totalFailed = 0;
+    this.totalDuration = 0;
+  }
+  /**
+   * Gracefully shutdown executor
+   */
+  async shutdown() {
+    logger.info("Shutting down Parallel Executor", {
+      activeCount: this.activeCount,
+      queueLength: this.queue.length
+    });
+    this.queue = [];
+    while (this.activeCount > 0) {
+      await this.delay(100);
+    }
+    logger.info("Parallel Executor shutdown complete");
+  }
+}
+export {
+  ParallelExecutor
+};
+//# sourceMappingURL=parallel-executor.js.map

package/dist/core/execution/parallel-executor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/execution/parallel-executor.ts"],
+  "sourcesContent": ["/**\n * Parallel Execution Engine for RLM\n * \n * Manages concurrent execution of multiple Claude API calls\n * with rate limiting, resource pooling, and failure recovery\n */\n\nimport { EventEmitter } from 'events';\nimport { logger } from '../monitoring/logger.js';\n\nexport interface ExecutionTask<T> {\n  id: string;\n  execute: () => Promise<T>;\n  priority?: number;\n  timeout?: number;\n  retries?: number;\n}\n\nexport interface ExecutionResult<T> {\n  taskId: string;\n  success: boolean;\n  result?: T;\n  error?: Error;\n  duration: number;\n  attempts: number;\n}\n\nexport interface ParallelExecutorOptions {\n  maxConcurrency?: number;\n  queueSize?: number;\n  defaultTimeout?: number;\n  defaultRetries?: number;\n  rateLimitPerMinute?: number;\n}\n\n/**\n * Parallel Executor for managing concurrent operations\n */\nexport class ParallelExecutor extends EventEmitter {\n  private maxConcurrency: number;\n  private queueSize: number;\n  private defaultTimeout: number;\n  private defaultRetries: number;\n  private rateLimitPerMinute: number;\n  \n  private activeCount: number = 0;\n  private queue: ExecutionTask<any>[] = [];\n  private rateLimitTokens: number;\n  private lastRateLimitReset: number;\n  \n  // Metrics\n  private totalExecuted: number = 0;\n  private totalSucceeded: number = 0;\n  private totalFailed: number = 0;\n  private totalDuration: number = 0;\n\n  constructor(maxConcurrency: number = 5, options: ParallelExecutorOptions = {}) {\n    super();\n    \n    this.maxConcurrency = maxConcurrency;\n    this.queueSize = options.queueSize || 100;\n    this.defaultTimeout = options.defaultTimeout || 300000; // 5 minutes\n    this.defaultRetries = options.defaultRetries || 3;\n    this.rateLimitPerMinute = options.rateLimitPerMinute || 60;\n    \n    this.rateLimitTokens = this.rateLimitPerMinute;\n    this.lastRateLimitReset = Date.now();\n    \n    logger.info('Parallel Executor initialized', {\n      maxConcurrency,\n      queueSize: this.queueSize,\n      rateLimitPerMinute: this.rateLimitPerMinute,\n    });\n  }\n  \n  /**\n   * Execute multiple tasks in parallel\n   */\n  async executeParallel<T>(\n    items: T[],\n    executor: (item: T, index: number) => Promise<void>,\n    options?: {\n      batchSize?: number;\n      delayBetweenBatches?: number;\n    }\n  ): Promise<ExecutionResult<void>[]> {\n    const results: ExecutionResult<void>[] = [];\n    const batchSize = options?.batchSize || this.maxConcurrency;\n    const delayBetweenBatches = options?.delayBetweenBatches || 0;\n    \n    // Process items in batches\n    for (let i = 0; i < items.length; i += batchSize) {\n      const batch = items.slice(i, i + batchSize);\n      const batchPromises = batch.map((item, index) => \n        this.executeWithTracking(\n          `parallel-${i + index}`,\n          () => executor(item, i + index)\n        )\n      );\n      \n      const batchResults = await Promise.allSettled(batchPromises);\n      \n      // Convert to ExecutionResult format\n      batchResults.forEach((result, index) => {\n        if (result.status === 'fulfilled') {\n          results.push(result.value);\n        } else {\n          results.push({\n            taskId: `parallel-${i + index}`,\n            success: false,\n            error: result.reason,\n            duration: 0,\n            attempts: 1,\n          });\n        }\n      });\n      \n      // Delay between batches if specified\n      if (delayBetweenBatches > 0 && i + batchSize < items.length) {\n        await this.delay(delayBetweenBatches);\n      }\n      \n      // Log batch progress\n      logger.debug('Batch completed', {\n        batchNumber: Math.floor(i / batchSize) + 1,\n        totalBatches: Math.ceil(items.length / batchSize),\n        successRate: results.filter(r => r.success).length / results.length,\n      });\n    }\n    \n    return results;\n  }\n  \n  /**\n   * Execute a single task with tracking and retries\n   */\n  async executeWithTracking<T>(\n    taskId: string,\n    executor: () => Promise<T>,\n    options?: {\n      timeout?: number;\n      retries?: number;\n    }\n  ): Promise<ExecutionResult<T>> {\n    const timeout = options?.timeout || this.defaultTimeout;\n    const maxRetries = options?.retries || this.defaultRetries;\n    \n    let attempts = 0;\n    let lastError: Error | undefined;\n    const startTime = Date.now();\n    \n    while (attempts < maxRetries) {\n      attempts++;\n      \n      try {\n        // Check rate limit\n        await this.checkRateLimit();\n        \n        // Wait for available slot\n        await this.waitForSlot();\n        \n        this.activeCount++;\n        this.emit('task-start', { taskId, attempt: attempts });\n        \n        // Execute with timeout\n        const result = await this.executeWithTimeout(executor, timeout);\n        \n        // Success\n        this.totalSucceeded++;\n        this.emit('task-success', { taskId, attempts });\n        \n        return {\n          taskId,\n          success: true,\n          result,\n          duration: Date.now() - startTime,\n          attempts,\n        };\n        \n      } catch (error) {\n        lastError = error as Error;\n        \n        logger.warn(`Task failed (attempt ${attempts}/${maxRetries})`, {\n          taskId,\n          error: lastError.message,\n        });\n        \n        this.emit('task-retry', { taskId, attempt: attempts, error: lastError });\n        \n        // Exponential backoff for retries\n        if (attempts < maxRetries) {\n          await this.delay(Math.pow(2, attempts) * 1000);\n        }\n        \n      } finally {\n        this.activeCount--;\n        this.totalExecuted++;\n        this.totalDuration += Date.now() - startTime;\n      }\n    }\n    \n    // All retries exhausted\n    this.totalFailed++;\n    this.emit('task-failed', { taskId, attempts, error: lastError });\n    \n    return {\n      taskId,\n      success: false,\n      error: lastError,\n      duration: Date.now() - startTime,\n      attempts,\n    };\n  }\n  \n  /**\n   * Execute task with timeout\n   */\n  private async executeWithTimeout<T>(\n    executor: () => Promise<T>,\n    timeout: number\n  ): Promise<T> {\n    return Promise.race([\n      executor(),\n      new Promise<T>((_, reject) => \n        setTimeout(() => reject(new Error('Task timeout')), timeout)\n      ),\n    ]);\n  }\n  \n  /**\n   * Check and enforce rate limiting\n   */\n  private async checkRateLimit(): Promise<void> {\n    const now = Date.now();\n    const timeSinceReset = now - this.lastRateLimitReset;\n    \n    // Reset tokens if a minute has passed\n    if (timeSinceReset >= 60000) {\n      this.rateLimitTokens = this.rateLimitPerMinute;\n      this.lastRateLimitReset = now;\n    }\n    \n    // Wait if no tokens available\n    if (this.rateLimitTokens <= 0) {\n      const waitTime = 60000 - timeSinceReset;\n      logger.debug(`Rate limit reached, waiting ${waitTime}ms`);\n      await this.delay(waitTime);\n      \n      // Reset after waiting\n      this.rateLimitTokens = this.rateLimitPerMinute;\n      this.lastRateLimitReset = Date.now();\n    }\n    \n    this.rateLimitTokens--;\n  }\n  \n  /**\n   * Wait for an available execution slot\n   */\n  private async waitForSlot(): Promise<void> {\n    while (this.activeCount >= this.maxConcurrency) {\n      await this.delay(100); // Check every 100ms\n    }\n  }\n  \n  /**\n   * Queue a task for execution\n   */\n  async queueTask<T>(task: ExecutionTask<T>): Promise<ExecutionResult<T>> {\n    if (this.queue.length >= this.queueSize) {\n      throw new Error('Execution queue is full');\n    }\n    \n    return new Promise((resolve) => {\n      this.queue.push({\n        ...task,\n        execute: async () => {\n          const result = await task.execute();\n          resolve({\n            taskId: task.id,\n            success: true,\n            result,\n            duration: 0,\n            attempts: 1,\n          });\n          return result;\n        },\n      });\n      \n      this.processQueue();\n    });\n  }\n  \n  /**\n   * Process queued tasks\n   */\n  private async processQueue(): Promise<void> {\n    if (this.activeCount >= this.maxConcurrency || this.queue.length === 0) {\n      return;\n    }\n    \n    // Sort by priority (higher first)\n    this.queue.sort((a, b) => (b.priority || 0) - (a.priority || 0));\n    \n    const task = this.queue.shift();\n    if (task) {\n      this.executeWithTracking(task.id, task.execute, {\n        timeout: task.timeout,\n        retries: task.retries,\n      }).then(() => {\n        this.processQueue(); // Process next task\n      });\n    }\n  }\n  \n  /**\n   * Utility delay function\n   */\n  private delay(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n  \n  /**\n   * Get execution metrics\n   */\n  getMetrics() {\n    return {\n      activeCount: this.activeCount,\n      queueLength: this.queue.length,\n      totalExecuted: this.totalExecuted,\n      totalSucceeded: this.totalSucceeded,\n      totalFailed: this.totalFailed,\n      successRate: this.totalExecuted > 0 ? this.totalSucceeded / this.totalExecuted : 0,\n      averageDuration: this.totalExecuted > 0 ? this.totalDuration / this.totalExecuted : 0,\n      rateLimitTokens: this.rateLimitTokens,\n    };\n  }\n  \n  /**\n   * Reset all metrics\n   */\n  resetMetrics(): void {\n    this.totalExecuted = 0;\n    this.totalSucceeded = 0;\n    this.totalFailed = 0;\n    this.totalDuration = 0;\n  }\n  \n  /**\n   * Gracefully shutdown executor\n   */\n  async shutdown(): Promise<void> {\n    logger.info('Shutting down Parallel Executor', {\n      activeCount: this.activeCount,\n      queueLength: this.queue.length,\n    });\n    \n    // Clear queue\n    this.queue = [];\n    \n    // Wait for active tasks to complete\n    while (this.activeCount > 0) {\n      await this.delay(100);\n    }\n    \n    logger.info('Parallel Executor shutdown complete');\n  }\n}"],
+  "mappings": "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",
+  "names": []
+}

package/dist/integrations/anthropic/client.js

@@ -0,0 +1,259 @@
+import { logger } from "../../core/monitoring/logger.js";
+class AnthropicClient {
+  apiKey;
+  baseURL;
+  maxRetries;
+  timeout;
+  // Rate limiting
+  requestCount = 0;
+  lastResetTime = Date.now();
+  rateLimitPerMinute = 60;
+  constructor(config) {
+    this.apiKey = config?.apiKey || process.env["ANTHROPIC_API_KEY"] || "";
+    this.baseURL = config?.baseURL || "https://api.anthropic.com";
+    this.maxRetries = config?.maxRetries || 3;
+    this.timeout = config?.timeout || 6e4;
+    if (!this.apiKey) {
+      logger.warn("Anthropic API key not configured. Using mock mode.");
+    }
+    logger.info("Anthropic client initialized", {
+      baseURL: this.baseURL,
+      maxRetries: this.maxRetries,
+      timeout: this.timeout,
+      mockMode: !this.apiKey
+    });
+  }
+  /**
+   * Send completion request to Claude
+   */
+  async complete(request) {
+    await this.checkRateLimit();
+    logger.debug("Sending completion request", {
+      model: request.model,
+      promptLength: request.prompt.length,
+      maxTokens: request.maxTokens
+    });
+    if (!this.apiKey) {
+      return this.mockComplete(request);
+    }
+    try {
+      const response = await this.sendRequest(request);
+      return response.content;
+    } catch (error) {
+      logger.error("Anthropic API error", { error });
+      throw error;
+    }
+  }
+  /**
+   * Send request with retry logic
+   */
+  async sendRequest(request, attempt = 1) {
+    try {
+      return this.createMockResponse(request);
+    } catch (error) {
+      if (attempt < this.maxRetries) {
+        const delay = Math.pow(2, attempt) * 1e3;
+        logger.warn(`Retrying after ${delay}ms (attempt ${attempt}/${this.maxRetries})`);
+        await this.delay(delay);
+        return this.sendRequest(request, attempt + 1);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Mock completion for development/testing
+   */
+  async mockComplete(request) {
+    await this.delay(500 + Math.random() * 1500);
+    if (request.systemPrompt.includes("Planning Agent")) {
+      return this.mockPlanningResponse(request.prompt);
+    } else if (request.systemPrompt.includes("Code Agent")) {
+      return this.mockCodeResponse(request.prompt);
+    } else if (request.systemPrompt.includes("Testing Agent")) {
+      return this.mockTestingResponse(request.prompt);
+    } else if (request.systemPrompt.includes("Review Agent")) {
+      return this.mockReviewResponse(request.prompt);
+    } else {
+      return `Mock response for: ${request.prompt.slice(0, 100)}...`;
+    }
+  }
+  /**
+   * Mock response generators
+   */
+  mockPlanningResponse(prompt) {
+    return JSON.stringify({
+      plan: {
+        type: "sequential",
+        tasks: [
+          {
+            id: "task-1",
+            description: "Analyze requirements",
+            agent: "context",
+            dependencies: []
+          },
+          {
+            id: "task-2",
+            type: "parallel",
+            description: "Implementation phase",
+            children: [
+              {
+                id: "task-2a",
+                description: "Write core logic",
+                agent: "code",
+                dependencies: ["task-1"]
+              },
+              {
+                id: "task-2b",
+                description: "Write tests",
+                agent: "testing",
+                dependencies: ["task-1"]
+              }
+            ]
+          },
+          {
+            id: "task-3",
+            description: "Review and improve",
+            agent: "review",
+            dependencies: ["task-2"]
+          }
+        ]
+      }
+    }, null, 2);
+  }
+  mockCodeResponse(prompt) {
+    return `
+// Mock implementation
+export function processTask(input: string): string {
+  // TODO: Implement actual logic
+  console.log('Processing:', input);
+  return \`Processed: \${input}\`;
+}
+
+export function validateInput(input: unknown): boolean {
+  return typeof input === 'string' && input.length > 0;
+}
+    `.trim();
+  }
+  mockTestingResponse(prompt) {
+    return `
+import { describe, test, expect } from 'vitest';
+import { processTask, validateInput } from './implementation';
+
+describe('processTask', () => {
+  test('should process valid input', () => {
+    const result = processTask('test input');
+    expect(result).toBe('Processed: test input');
+  });
+  
+  test('should handle empty input', () => {
+    const result = processTask('');
+    expect(result).toBe('Processed: ');
+  });
+});
+
+describe('validateInput', () => {
+  test('should validate string input', () => {
+    expect(validateInput('valid')).toBe(true);
+    expect(validateInput('')).toBe(false);
+    expect(validateInput(123)).toBe(false);
+    expect(validateInput(null)).toBe(false);
+  });
+});
+    `.trim();
+  }
+  mockReviewResponse(prompt) {
+    return JSON.stringify({
+      quality: 0.75,
+      issues: [
+        "Missing error handling in processTask function",
+        "No input validation before processing",
+        "Tests could cover more edge cases"
+      ],
+      suggestions: [
+        "Add try-catch block in processTask",
+        "Validate input length and type",
+        "Add tests for special characters and long inputs",
+        "Consider adding performance tests"
+      ],
+      improvements: [
+        {
+          file: "implementation.ts",
+          line: 3,
+          suggestion: "Add input validation",
+          priority: "high"
+        },
+        {
+          file: "tests.ts",
+          line: 15,
+          suggestion: "Add edge case tests",
+          priority: "medium"
+        }
+      ]
+    }, null, 2);
+  }
+  /**
+   * Create mock response object
+   */
+  createMockResponse(request) {
+    const content = this.mockComplete(request).toString();
+    return {
+      content,
+      stopReason: "stop_sequence",
+      model: request.model,
+      usage: {
+        inputTokens: Math.ceil(request.prompt.length / 4),
+        outputTokens: Math.ceil(content.length / 4)
+      }
+    };
+  }
+  /**
+   * Check rate limiting
+   */
+  async checkRateLimit() {
+    const now = Date.now();
+    const timeSinceReset = now - this.lastResetTime;
+    if (timeSinceReset >= 6e4) {
+      this.requestCount = 0;
+      this.lastResetTime = now;
+    }
+    if (this.requestCount >= this.rateLimitPerMinute) {
+      const waitTime = 6e4 - timeSinceReset;
+      logger.warn(`Rate limit reached, waiting ${waitTime}ms`);
+      await this.delay(waitTime);
+      this.requestCount = 0;
+      this.lastResetTime = Date.now();
+    }
+    this.requestCount++;
+  }
+  /**
+   * Stream completion response
+   */
+  async *streamComplete(request) {
+    const response = await this.complete(request);
+    const words = response.split(" ");
+    for (const word of words) {
+      yield word + " ";
+      await this.delay(50);
+    }
+  }
+  /**
+   * Utility delay function
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get API usage statistics
+   */
+  getUsageStats() {
+    return {
+      requestCount: this.requestCount,
+      rateLimitRemaining: this.rateLimitPerMinute - this.requestCount,
+      resetTime: new Date(this.lastResetTime + 6e4).toISOString()
+    };
+  }
+}
+export {
+  AnthropicClient
+};
+//# sourceMappingURL=client.js.map

package/dist/integrations/anthropic/client.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/integrations/anthropic/client.ts"],
+  "sourcesContent": ["/**\n * Anthropic API Client for Claude Integration\n * \n * Manages API calls to Claude with retry logic, rate limiting,\n * and response streaming\n */\n\nimport { logger } from '../../core/monitoring/logger.js';\n\nexport interface CompletionRequest {\n  model: string;\n  systemPrompt: string;\n  prompt: string;\n  maxTokens: number;\n  temperature: number;\n  stream?: boolean;\n}\n\nexport interface CompletionResponse {\n  content: string;\n  stopReason: string;\n  model: string;\n  usage: {\n    inputTokens: number;\n    outputTokens: number;\n  };\n}\n\nexport interface AnthropicClientConfig {\n  apiKey?: string;\n  baseURL?: string;\n  maxRetries?: number;\n  timeout?: number;\n}\n\n/**\n * Anthropic API Client\n * \n * NOTE: This is a mock implementation. In production, you would:\n * 1. Install @anthropic-ai/sdk: npm install @anthropic-ai/sdk\n * 2. Use the actual SDK methods\n * 3. Handle real API responses\n */\nexport class AnthropicClient {\n  private apiKey: string;\n  private baseURL: string;\n  private maxRetries: number;\n  private timeout: number;\n  \n  // Rate limiting\n  private requestCount: number = 0;\n  private lastResetTime: number = Date.now();\n  private rateLimitPerMinute: number = 60;\n  \n  constructor(config?: AnthropicClientConfig) {\n    this.apiKey = config?.apiKey || process.env['ANTHROPIC_API_KEY'] || '';\n    this.baseURL = config?.baseURL || 'https://api.anthropic.com';\n    this.maxRetries = config?.maxRetries || 3;\n    this.timeout = config?.timeout || 60000;\n    \n    if (!this.apiKey) {\n      logger.warn('Anthropic API key not configured. Using mock mode.');\n    }\n    \n    logger.info('Anthropic client initialized', {\n      baseURL: this.baseURL,\n      maxRetries: this.maxRetries,\n      timeout: this.timeout,\n      mockMode: !this.apiKey,\n    });\n  }\n  \n  /**\n   * Send completion request to Claude\n   */\n  async complete(request: CompletionRequest): Promise<string> {\n    // Rate limiting check\n    await this.checkRateLimit();\n    \n    logger.debug('Sending completion request', {\n      model: request.model,\n      promptLength: request.prompt.length,\n      maxTokens: request.maxTokens,\n    });\n    \n    // Mock implementation for development\n    if (!this.apiKey) {\n      return this.mockComplete(request);\n    }\n    \n    // Real implementation would use Anthropic SDK\n    try {\n      const response = await this.sendRequest(request);\n      return response.content;\n    } catch (error) {\n      logger.error('Anthropic API error', { error });\n      throw error;\n    }\n  }\n  \n  /**\n   * Send request with retry logic\n   */\n  private async sendRequest(\n    request: CompletionRequest,\n    attempt: number = 1\n  ): Promise<CompletionResponse> {\n    try {\n      // In production, use actual Anthropic SDK:\n      /*\n      import Anthropic from '@anthropic-ai/sdk';\n      \n      const anthropic = new Anthropic({\n        apiKey: this.apiKey,\n      });\n      \n      const response = await anthropic.messages.create({\n        model: request.model,\n        system: request.systemPrompt,\n        messages: [{ role: 'user', content: request.prompt }],\n        max_tokens: request.maxTokens,\n        temperature: request.temperature,\n      });\n      \n      return {\n        content: response.content[0].text,\n        stopReason: response.stop_reason,\n        model: response.model,\n        usage: {\n          inputTokens: response.usage.input_tokens,\n          outputTokens: response.usage.output_tokens,\n        },\n      };\n      */\n      \n      // Mock response for now\n      return this.createMockResponse(request);\n      \n    } catch (error: any) {\n      if (attempt < this.maxRetries) {\n        const delay = Math.pow(2, attempt) * 1000;\n        logger.warn(`Retrying after ${delay}ms (attempt ${attempt}/${this.maxRetries})`);\n        await this.delay(delay);\n        return this.sendRequest(request, attempt + 1);\n      }\n      throw error;\n    }\n  }\n  \n  /**\n   * Mock completion for development/testing\n   */\n  private async mockComplete(request: CompletionRequest): Promise<string> {\n    // Simulate API delay\n    await this.delay(500 + Math.random() * 1500);\n    \n    // Generate mock response based on agent type\n    if (request.systemPrompt.includes('Planning Agent')) {\n      return this.mockPlanningResponse(request.prompt);\n    } else if (request.systemPrompt.includes('Code Agent')) {\n      return this.mockCodeResponse(request.prompt);\n    } else if (request.systemPrompt.includes('Testing Agent')) {\n      return this.mockTestingResponse(request.prompt);\n    } else if (request.systemPrompt.includes('Review Agent')) {\n      return this.mockReviewResponse(request.prompt);\n    } else {\n      return `Mock response for: ${request.prompt.slice(0, 100)}...`;\n    }\n  }\n  \n  /**\n   * Mock response generators\n   */\n  \n  private mockPlanningResponse(prompt: string): string {\n    return JSON.stringify({\n      plan: {\n        type: 'sequential',\n        tasks: [\n          {\n            id: 'task-1',\n            description: 'Analyze requirements',\n            agent: 'context',\n            dependencies: [],\n          },\n          {\n            id: 'task-2',\n            type: 'parallel',\n            description: 'Implementation phase',\n            children: [\n              {\n                id: 'task-2a',\n                description: 'Write core logic',\n                agent: 'code',\n                dependencies: ['task-1'],\n              },\n              {\n                id: 'task-2b',\n                description: 'Write tests',\n                agent: 'testing',\n                dependencies: ['task-1'],\n              },\n            ],\n          },\n          {\n            id: 'task-3',\n            description: 'Review and improve',\n            agent: 'review',\n            dependencies: ['task-2'],\n          },\n        ],\n      },\n    }, null, 2);\n  }\n  \n  private mockCodeResponse(prompt: string): string {\n    return `\n// Mock implementation\nexport function processTask(input: string): string {\n  // TODO: Implement actual logic\n  console.log('Processing:', input);\n  return \\`Processed: \\${input}\\`;\n}\n\nexport function validateInput(input: unknown): boolean {\n  return typeof input === 'string' && input.length > 0;\n}\n    `.trim();\n  }\n  \n  private mockTestingResponse(prompt: string): string {\n    return `\nimport { describe, test, expect } from 'vitest';\nimport { processTask, validateInput } from './implementation';\n\ndescribe('processTask', () => {\n  test('should process valid input', () => {\n    const result = processTask('test input');\n    expect(result).toBe('Processed: test input');\n  });\n  \n  test('should handle empty input', () => {\n    const result = processTask('');\n    expect(result).toBe('Processed: ');\n  });\n});\n\ndescribe('validateInput', () => {\n  test('should validate string input', () => {\n    expect(validateInput('valid')).toBe(true);\n    expect(validateInput('')).toBe(false);\n    expect(validateInput(123)).toBe(false);\n    expect(validateInput(null)).toBe(false);\n  });\n});\n    `.trim();\n  }\n  \n  private mockReviewResponse(prompt: string): string {\n    return JSON.stringify({\n      quality: 0.75,\n      issues: [\n        'Missing error handling in processTask function',\n        'No input validation before processing',\n        'Tests could cover more edge cases',\n      ],\n      suggestions: [\n        'Add try-catch block in processTask',\n        'Validate input length and type',\n        'Add tests for special characters and long inputs',\n        'Consider adding performance tests',\n      ],\n      improvements: [\n        {\n          file: 'implementation.ts',\n          line: 3,\n          suggestion: 'Add input validation',\n          priority: 'high',\n        },\n        {\n          file: 'tests.ts',\n          line: 15,\n          suggestion: 'Add edge case tests',\n          priority: 'medium',\n        },\n      ],\n    }, null, 2);\n  }\n  \n  /**\n   * Create mock response object\n   */\n  private createMockResponse(request: CompletionRequest): CompletionResponse {\n    const content = this.mockComplete(request).toString();\n    \n    return {\n      content,\n      stopReason: 'stop_sequence',\n      model: request.model,\n      usage: {\n        inputTokens: Math.ceil(request.prompt.length / 4),\n        outputTokens: Math.ceil(content.length / 4),\n      },\n    };\n  }\n  \n  /**\n   * Check rate limiting\n   */\n  private async checkRateLimit(): Promise<void> {\n    const now = Date.now();\n    const timeSinceReset = now - this.lastResetTime;\n    \n    if (timeSinceReset >= 60000) {\n      this.requestCount = 0;\n      this.lastResetTime = now;\n    }\n    \n    if (this.requestCount >= this.rateLimitPerMinute) {\n      const waitTime = 60000 - timeSinceReset;\n      logger.warn(`Rate limit reached, waiting ${waitTime}ms`);\n      await this.delay(waitTime);\n      this.requestCount = 0;\n      this.lastResetTime = Date.now();\n    }\n    \n    this.requestCount++;\n  }\n  \n  /**\n   * Stream completion response\n   */\n  async *streamComplete(request: CompletionRequest): AsyncGenerator<string> {\n    // Mock streaming implementation\n    const response = await this.complete(request);\n    const words = response.split(' ');\n    \n    for (const word of words) {\n      yield word + ' ';\n      await this.delay(50); // Simulate streaming delay\n    }\n  }\n  \n  /**\n   * Utility delay function\n   */\n  private delay(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n  \n  /**\n   * Get API usage statistics\n   */\n  getUsageStats() {\n    return {\n      requestCount: this.requestCount,\n      rateLimitRemaining: this.rateLimitPerMinute - this.requestCount,\n      resetTime: new Date(this.lastResetTime + 60000).toISOString(),\n    };\n  }\n}"],
+  "mappings": "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",
+  "names": []
+}