@stackmemoryai/stackmemory 0.3.7 → 0.3.9

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": []
+}

package/dist/integrations/claude-code/subagent-client.js

@@ -0,0 +1,404 @@
+import { logger } from "../../core/monitoring/logger.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const execAsync = promisify(exec);
+class ClaudeCodeSubagentClient {
+  tempDir;
+  activeSubagents = /* @__PURE__ */ new Map();
+  constructor() {
+    this.tempDir = path.join(os.tmpdir(), "stackmemory-rlm");
+    if (!fs.existsSync(this.tempDir)) {
+      fs.mkdirSync(this.tempDir, { recursive: true });
+    }
+    logger.info("Claude Code Subagent Client initialized", {
+      tempDir: this.tempDir
+    });
+  }
+  /**
+   * Execute a subagent task using Claude Code's Task tool
+   * This will spawn a new Claude instance with specific instructions
+   */
+  async executeSubagent(request) {
+    const startTime = Date.now();
+    const subagentId = `${request.type}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    logger.info(`Spawning ${request.type} subagent`, {
+      subagentId,
+      task: request.task.slice(0, 100)
+    });
+    try {
+      const prompt = this.buildSubagentPrompt(request);
+      const contextFile = path.join(this.tempDir, `${subagentId}-context.json`);
+      await fs.promises.writeFile(
+        contextFile,
+        JSON.stringify(request.context, null, 2)
+      );
+      const resultFile = path.join(this.tempDir, `${subagentId}-result.json`);
+      const taskCommand = this.buildTaskCommand(request, prompt, contextFile, resultFile);
+      const result = await this.executeTaskTool(taskCommand, request.timeout);
+      let subagentResult = {};
+      if (fs.existsSync(resultFile)) {
+        const resultContent = await fs.promises.readFile(resultFile, "utf-8");
+        try {
+          subagentResult = JSON.parse(resultContent);
+        } catch (e) {
+          subagentResult = { rawOutput: resultContent };
+        }
+      }
+      this.cleanup(subagentId);
+      return {
+        success: true,
+        result: subagentResult,
+        output: result.stdout,
+        duration: Date.now() - startTime,
+        subagentType: request.type,
+        tokens: this.estimateTokens(prompt + JSON.stringify(subagentResult))
+      };
+    } catch (error) {
+      logger.error(`Subagent execution failed: ${request.type}`, { error, subagentId });
+      return {
+        success: false,
+        result: null,
+        error: error.message,
+        duration: Date.now() - startTime,
+        subagentType: request.type
+      };
+    }
+  }
+  /**
+   * Execute multiple subagents in parallel
+   */
+  async executeParallel(requests) {
+    logger.info(`Executing ${requests.length} subagents in parallel`);
+    const promises = requests.map((request) => this.executeSubagent(request));
+    const results = await Promise.allSettled(promises);
+    return results.map((result, index) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      } else {
+        return {
+          success: false,
+          result: null,
+          error: result.reason?.message || "Unknown error",
+          duration: 0,
+          subagentType: requests[index].type
+        };
+      }
+    });
+  }
+  /**
+   * Build subagent prompt based on type
+   */
+  buildSubagentPrompt(request) {
+    const prompts = {
+      planning: `You are a Planning Subagent. Your role is to decompose complex tasks into manageable subtasks.
+        
+        Task: ${request.task}
+        
+        Instructions:
+        1. Analyze the task and identify all components
+        2. Create a dependency graph of subtasks
+        3. Assign appropriate agent types to each subtask
+        4. Consider parallel execution opportunities
+        5. Include comprehensive testing at each stage
+        
+        Context is available in the provided file.
+        
+        Output a JSON structure with the task decomposition.`,
+      code: `You are a Code Generation Subagent. Your role is to implement high-quality, production-ready code.
+        
+        Task: ${request.task}
+        
+        Instructions:
+        1. Write clean, maintainable code
+        2. Follow project conventions (check context)
+        3. Include comprehensive error handling
+        4. Add clear comments for complex logic
+        5. Ensure code is testable
+        
+        Context and requirements are in the provided file.
+        
+        Output the implementation code.`,
+      testing: `You are a Testing Subagent specializing in comprehensive test generation.
+        
+        Task: ${request.task}
+        
+        Instructions:
+        1. Generate unit tests for all functions/methods
+        2. Create integration tests for API endpoints
+        3. Add E2E tests for critical user flows
+        4. Include edge cases and error scenarios
+        5. Ensure high code coverage (aim for 100%)
+        6. Validate that all tests pass
+        
+        Context and code to test are in the provided file.
+        
+        Output a complete test suite.`,
+      linting: `You are a Linting Subagent ensuring code quality and standards.
+        
+        Task: ${request.task}
+        
+        Instructions:
+        1. Check for syntax errors and type issues
+        2. Verify code formatting and style
+        3. Identify security vulnerabilities
+        4. Find performance anti-patterns
+        5. Detect unused imports and dead code
+        6. Provide specific fixes for each issue
+        
+        Code to analyze is in the context file.
+        
+        Output a JSON report with issues and fixes.`,
+      review: `You are a Code Review Subagent performing thorough multi-stage reviews.
+        
+        Task: ${request.task}
+        
+        Instructions:
+        1. Evaluate architecture and design patterns
+        2. Assess code quality and maintainability
+        3. Check performance implications
+        4. Review security considerations
+        5. Verify test coverage adequacy
+        6. Suggest specific improvements with examples
+        7. Rate quality on a 0-1 scale
+        
+        Code and context are in the provided file.
+        
+        Output a detailed review with quality score and improvements.`,
+      improve: `You are an Improvement Subagent enhancing code based on reviews.
+        
+        Task: ${request.task}
+        
+        Instructions:
+        1. Implement all suggested improvements
+        2. Refactor for better architecture
+        3. Optimize performance bottlenecks
+        4. Enhance error handling
+        5. Improve code clarity and documentation
+        6. Add missing test cases
+        7. Ensure backward compatibility
+        
+        Review feedback and code are in the context file.
+        
+        Output the improved code.`,
+      context: `You are a Context Retrieval Subagent finding relevant information.
+        
+        Task: ${request.task}
+        
+        Instructions:
+        1. Search project codebase for relevant code
+        2. Find similar implementations
+        3. Locate relevant documentation
+        4. Identify dependencies and patterns
+        5. Retrieve best practices
+        
+        Search parameters are in the context file.
+        
+        Output relevant context snippets.`,
+      publish: `You are a Publishing Subagent handling releases and deployments.
+        
+        Task: ${request.task}
+        
+        Instructions:
+        1. Prepare package for publishing
+        2. Update version numbers
+        3. Generate changelog
+        4. Create GitHub release
+        5. Publish to NPM if applicable
+        6. Update documentation
+        
+        Release details are in the context file.
+        
+        Output the release plan and commands.`
+    };
+    return request.systemPrompt || prompts[request.type] || prompts.planning;
+  }
+  /**
+   * Build Task tool command
+   * This creates a command that Claude Code's Task tool can execute
+   */
+  buildTaskCommand(request, prompt, contextFile, resultFile) {
+    const scriptContent = `
+#!/bin/bash
+# Subagent execution script for ${request.type}
+
+# Read context
+CONTEXT=$(cat "${contextFile}")
+
+# Execute task based on type
+case "${request.type}" in
+  "testing")
+    # For testing subagent, actually run tests
+    echo "Generating and running tests..."
+    # The subagent will generate test files and run them
+    ;;
+  "linting")
+    # For linting subagent, run actual linters
+    echo "Running linters..."
+    npm run lint || true
+    ;;
+  "code")
+    # For code generation, create implementation files
+    echo "Generating implementation..."
+    ;;
+  *)
+    # Default behavior
+    echo "Executing ${request.type} task..."
+    ;;
+esac
+
+# Write result
+echo '{"status": "completed", "type": "${request.type}"}' > "${resultFile}"
+`;
+    const scriptFile = path.join(this.tempDir, `${request.type}-script.sh`);
+    fs.writeFileSync(scriptFile, scriptContent);
+    fs.chmodSync(scriptFile, "755");
+    return scriptFile;
+  }
+  /**
+   * Execute via Task tool (simulated for now)
+   * In production, this would use Claude Code's actual Task tool API
+   */
+  async executeTaskTool(command, timeout) {
+    try {
+      const result = await execAsync(command, {
+        timeout: timeout || 3e5,
+        // 5 minutes default
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB buffer
+      });
+      return result;
+    } catch (error) {
+      if (error.killed || error.signal === "SIGTERM") {
+        throw new Error(`Subagent timeout after ${timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Estimate token usage
+   */
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Cleanup temporary files
+   */
+  cleanup(subagentId) {
+    const patterns = [
+      `${subagentId}-context.json`,
+      `${subagentId}-result.json`,
+      `${subagentId}-script.sh`
+    ];
+    for (const pattern of patterns) {
+      const filePath = path.join(this.tempDir, pattern);
+      if (fs.existsSync(filePath)) {
+        try {
+          fs.unlinkSync(filePath);
+        } catch (e) {
+        }
+      }
+    }
+  }
+  /**
+   * Create a mock Task tool response for development
+   * This simulates what Claude Code's Task tool would return
+   */
+  async mockTaskToolExecution(request) {
+    const startTime = Date.now();
+    await new Promise((resolve) => setTimeout(resolve, 1e3 + Math.random() * 2e3));
+    const mockResponses = {
+      planning: {
+        tasks: [
+          { id: "1", type: "analyze", description: "Analyze requirements" },
+          { id: "2", type: "implement", description: "Implement solution" },
+          { id: "3", type: "test", description: "Test implementation" },
+          { id: "4", type: "review", description: "Review and improve" }
+        ],
+        dependencies: { "2": ["1"], "3": ["2"], "4": ["3"] }
+      },
+      code: {
+        implementation: `
+export class Solution {
+  constructor(private config: any) {}
+  
+  async execute(input: string): Promise<string> {
+    // Implementation generated by Code subagent
+    return this.process(input);
+  }
+  
+  private process(input: string): string {
+    return \`Processed: \${input}\`;
+  }
+}`,
+        files: ["src/solution.ts"]
+      },
+      testing: {
+        tests: `
+describe('Solution', () => {
+  it('should process input correctly', () => {
+    const solution = new Solution({});
+    const result = solution.execute('test');
+    expect(result).toBe('Processed: test');
+  });
+  
+  it('should handle edge cases', () => {
+    // Edge case tests
+  });
+});`,
+        coverage: { lines: 95, branches: 88, functions: 100 }
+      },
+      review: {
+        quality: 0.82,
+        issues: [
+          { severity: "high", message: "Missing error handling" },
+          { severity: "medium", message: "Could improve type safety" }
+        ],
+        suggestions: [
+          "Add try-catch blocks",
+          "Use stricter TypeScript types",
+          "Add input validation"
+        ]
+      }
+    };
+    return {
+      success: true,
+      result: mockResponses[request.type] || { status: "completed" },
+      output: `Mock ${request.type} subagent completed successfully`,
+      duration: Date.now() - startTime,
+      subagentType: request.type,
+      tokens: Math.floor(Math.random() * 5e3) + 1e3
+    };
+  }
+  /**
+   * Get active subagent statistics
+   */
+  getStats() {
+    return {
+      activeSubagents: this.activeSubagents.size,
+      tempDir: this.tempDir
+    };
+  }
+  /**
+   * Cleanup all resources
+   */
+  async cleanupAll() {
+    for (const [id, controller] of this.activeSubagents) {
+      controller.abort();
+    }
+    this.activeSubagents.clear();
+    if (fs.existsSync(this.tempDir)) {
+      const files = await fs.promises.readdir(this.tempDir);
+      for (const file of files) {
+        await fs.promises.unlink(path.join(this.tempDir, file));
+      }
+    }
+    logger.info("Claude Code Subagent Client cleaned up");
+  }
+}
+export {
+  ClaudeCodeSubagentClient
+};
+//# sourceMappingURL=subagent-client.js.map