@capyclaw/tool-host 0.1.0 → 0.1.1

package/src/optimizers/examples.mjs

@@ -1,243 +0,0 @@
-/**
- * MCP 2.0 优化示例
- * 
- * 展示如何在实际项目中使用优化器
- */
-
-import { createOptimizedExecutor } from './optimizers/index.mjs';
-import { Client } from '@modelcontextprotocol/client';
-
-// ============================================
-// 示例 1: 基础使用
-// ============================================
-
-async function basicExample() {
-  // 创建 MCP 客户端
-  const client = new Client({
-    name: 'dsh-example',
-    version: '1.0.0'
-  });
-
-  // 创建优化执行器
-  const executor = createOptimizedExecutor(client, {
-    batchSize: 10,          // 批量大小
-    maxConcurrent: 20,      // 最大并发
-    maxRetries: 3,          // 最大重试次数
-    cacheTTL: 300000        // 缓存5分钟
-  });
-
-  // 普通调用（自动重试+并发控制）
-  const result = await executor.callTool('analyze_text', {
-    text: 'Hello world'
-  });
-  
-  console.log('Result:', result);
-}
-
-// ============================================
-// 示例 2: 批量操作
-// ============================================
-
-async function batchExample(executor) {
-  console.log('=== 批量操作示例 ===\n');
-
-  // 批量调用（自动合并为一个请求）
-  const start = Date.now();
-  
-  const results = await Promise.all([
-    executor.callTool('process_item', { id: 1 }, { batch: true }),
-    executor.callTool('process_item', { id: 2 }, { batch: true }),
-    executor.callTool('process_item', { id: 3 }, { batch: true }),
-    executor.callTool('process_item', { id: 4 }, { batch: true }),
-    executor.callTool('process_item', { id: 5 }, { batch: true }),
-  ]);
-  
-  const duration = Date.now() - start;
-  console.log(`✅ 批量处理完成: ${results.length} items in ${duration}ms`);
-  console.log(`   平均: ${(duration / results.length).toFixed(2)}ms/item\n`);
-}
-
-// ============================================
-// 示例 3: 智能缓存
-// ============================================
-
-async function cacheExample(executor) {
-  console.log('=== 智能缓存示例 ===\n');
-
-  // 第一次调用（无缓存）
-  console.log('第一次调用...');
-  const start1 = Date.now();
-  const schema1 = await executor.callTool('get_tool_schema', 
-    { name: 'my_tool' },
-    { cacheable: true }
-  );
-  console.log(`  耗时: ${Date.now() - start1}ms\n`);
-
-  // 第二次调用（命中缓存）
-  console.log('第二次调用（应该命中缓存）...');
-  const start2 = Date.now();
-  const schema2 = await executor.callTool('get_tool_schema', 
-    { name: 'my_tool' },
-    { cacheable: true }
-  );
-  console.log(`  耗时: ${Date.now() - start2}ms`);
-  console.log(`  性能提升: ${Math.floor((Date.now() - start1) / (Date.now() - start2))}x\n`);
-}
-
-// ============================================
-// 示例 4: 并发控制
-// ============================================
-
-async function concurrencyExample(executor) {
-  console.log('=== 并发控制示例 ===\n');
-
-  const items = Array.from({ length: 50 }, (_, i) => i + 1);
-  
-  console.log(`处理 ${items.length} 个任务...`);
-  const start = Date.now();
-
-  // 自动限流（不会压垮服务器）
-  const results = await Promise.all(
-    items.map(id => 
-      executor.callTool('heavy_task', { id })
-    )
-  );
-
-  const duration = Date.now() - start;
-  console.log(`✅ 完成: ${results.length} tasks in ${duration}ms`);
-  console.log(`   吞吐量: ${(results.length / (duration / 1000)).toFixed(2)} ops/s\n`);
-}
-
-// ============================================
-// 示例 5: 智能重试
-// ============================================
-
-async function retryExample(executor) {
-  console.log('=== 智能重试示例 ===\n');
-
-  try {
-    // 模拟不稳定的网络调用
-    const result = await executor.callTool('unstable_api', {
-      url: 'https://example.com/api',
-      failRate: 0.5  // 50% 失败率
-    });
-    
-    console.log('✅ 调用成功（可能经过重试）:', result);
-  } catch (error) {
-    console.log('❌ 所有重试失败:', error.message);
-  }
-}
-
-// ============================================
-// 示例 6: 统计监控
-// ============================================
-
-async function monitoringExample(executor) {
-  console.log('=== 统计监控示例 ===\n');
-
-  // 执行一些操作
-  await executor.callTool('task1', {});
-  await executor.callTool('task2', {}, { batch: true });
-  await executor.callTool('task3', {}, { cacheable: true });
-
-  // 获取统计信息
-  const stats = executor.getStats();
-  
-  console.log('📊 执行统计:');
-  console.log('  总调用:', stats.calls);
-  console.log('  批量调用:', stats.batched);
-  console.log('  缓存命中:', stats.cached);
-  console.log('  错误数:', stats.errors);
-  console.log('  缓存命中率:', stats.cacheHitRate);
-  console.log('  错误率:', stats.errorRate);
-  console.log('  RPS:', stats.rps);
-  console.log('  运行时间:', (stats.runtime / 1000).toFixed(2) + 's\n');
-  
-  console.log('📈 并发状态:');
-  console.log('  当前并发:', stats.concurrency.currentConcurrent);
-  console.log('  运行中:', stats.concurrency.running);
-  console.log('  队列中:', stats.concurrency.queued);
-  console.log('  成功:', stats.concurrency.successCount);
-  console.log('  失败:', stats.concurrency.errorCount);
-  console.log('\n');
-}
-
-// ============================================
-// 示例 7: 与现有 tool-host 集成
-// ============================================
-
-export function createOptimizedToolHost(capabilities, options = {}) {
-  const registry = createRegistry(capabilities, options);
-  
-  // 创建优化执行器
-  const executor = createOptimizedExecutor(registry.client, {
-    batchSize: options.batchSize || 10,
-    maxConcurrent: options.maxConcurrent || 20,
-    maxRetries: options.maxRetries || 3
-  });
-
-  return {
-    tools: registry.TOOLS,
-    
-    // 优化的 callTool
-    async callTool(name, args, context = {}) {
-      // 根据工具类型自动选择策略
-      const tool = registry.TOOL_META[name];
-      
-      if (!tool) {
-        throw new Error(`Tool not found: ${name}`);
-      }
-
-      const options = {
-        // 读取操作可以缓存
-        cacheable: tool.kind === 'read',
-        // 多个同类操作可以批量
-        batch: context.enableBatch || false
-      };
-
-      return executor.callTool(name, args, options);
-    },
-
-    // 批量调用
-    async callTools(calls) {
-      return executor.callTools(calls);
-    },
-
-    // 获取统计
-    getStats() {
-      return executor.getStats();
-    }
-  };
-}
-
-// ============================================
-// 完整运行示例
-// ============================================
-
-async function main() {
-  console.log('🚀 MCP 2.0 优化器演示\n');
-  console.log('='.repeat(50) + '\n');
-
-  const client = new Client({ name: 'demo', version: '1.0.0' });
-  const executor = createOptimizedExecutor(client);
-
-  try {
-    await basicExample();
-    await batchExample(executor);
-    await cacheExample(executor);
-    await concurrencyExample(executor);
-    await retryExample(executor);
-    await monitoringExample(executor);
-    
-    console.log('✅ 所有示例运行完成！');
-  } catch (error) {
-    console.error('❌ 错误:', error);
-  } finally {
-    executor.destroy();
-  }
-}
-
-// 如果直接运行此文件
-if (import.meta.url === `file://${process.argv[1]}`) {
-  main().catch(console.error);
-}

package/src/optimizers/index.mjs

@@ -1,188 +0,0 @@
-/**
- * MCP 2.0 统一优化执行器
- * 
- * 整合所有优化特性：
- * - 批量操作
- * - 智能重试
- * - 并发控制
- * - 资源缓存
- * - 流式响应（预留）
- */
-
-import { BatchToolExecutor } from './batch-optimizer.mjs';
-import { RetryManager } from './retry-optimizer.mjs';
-import { AdaptiveConcurrencyManager } from './concurrency-optimizer.mjs';
-import { CachedToolExecutor } from './cache-optimizer.mjs';
-
-export class OptimizedMCPExecutor {
-  constructor(client, options = {}) {
-    this.client = client;
-    this.options = options;
-
-    // 批量执行器
-    this.batchExecutor = new BatchToolExecutor(client, {
-      batchSize: options.batchSize || 10,
-      batchTimeout: options.batchTimeout || 100
-    });
-
-    // 并发管理器
-    this.concurrencyManager = new AdaptiveConcurrencyManager({
-      min: options.minConcurrent || 1,
-      max: options.maxConcurrent || 20,
-      initial: options.initialConcurrent || 5
-    });
-
-    // 重试管理器
-    this.retryManager = new RetryManager({
-      maxRetries: options.maxRetries || 3,
-      initialDelay: options.retryDelay || 1000
-    });
-
-    // 缓存执行器
-    this.cachedExecutor = new CachedToolExecutor(client, {
-      schemaTTL: options.schemaTTL || 3600000,
-      resultTTL: options.resultTTL || 60000,
-      maxSize: options.cacheSize || 1000
-    });
-
-    // 统计信息
-    this.stats = {
-      calls: 0,
-      batched: 0,
-      cached: 0,
-      retried: 0,
-      errors: 0,
-      startTime: Date.now()
-    };
-  }
-
-  /**
-   * 智能工具调用
-   * 自动选择最优执行策略
-   */
-  async callTool(name, args, options = {}) {
-    this.stats.calls++;
-
-    try {
-      // 1. 检查缓存（对于schema查询等幂等操作）
-      if (options.cacheable) {
-        this.stats.cached++;
-        return await this.cachedExecutor.callTool(name, args, options);
-      }
-
-      // 2. 批量调用（对于可以合并的操作）
-      if (options.batch) {
-        this.stats.batched++;
-        return await this.batchExecutor.callTool(name, args);
-      }
-
-      // 3. 普通调用（带重试和并发控制）
-      return await this.concurrencyManager.execute(async () => {
-        return await this.retryManager.execute(async () => {
-          return await this.client.request('tools/call', {
-            name,
-            arguments: args
-          });
-        });
-      });
-
-    } catch (error) {
-      this.stats.errors++;
-      throw error;
-    }
-  }
-
-  /**
-   * 批量调用多个工具
-   */
-  async callTools(calls, options = {}) {
-    return Promise.all(
-      calls.map(call => 
-        this.callTool(call.name, call.args, {
-          ...options,
-          ...call.options
-        })
-      )
-    );
-  }
-
-  /**
-   * 获取工具列表（带缓存）
-   */
-  async listTools() {
-    return this.callTool('tools/list', {}, { 
-      cacheable: true,
-      cacheKey: 'tools_list',
-      cacheTTL: 600000 // 10分钟
-    });
-  }
-
-  /**
-   * 获取统计信息
-   */
-  getStats() {
-    const runtime = Date.now() - this.stats.startTime;
-    const rps = this.stats.calls / (runtime / 1000);
-
-    return {
-      ...this.stats,
-      runtime,
-      rps: rps.toFixed(2),
-      cacheHitRate: (this.stats.cached / this.stats.calls * 100).toFixed(1) + '%',
-      errorRate: (this.stats.errors / this.stats.calls * 100).toFixed(1) + '%',
-      concurrency: this.concurrencyManager.getStats(),
-      cache: this.cachedExecutor.getStats()
-    };
-  }
-
-  /**
-   * 重置统计
-   */
-  resetStats() {
-    this.stats = {
-      calls: 0,
-      batched: 0,
-      cached: 0,
-      retried: 0,
-      errors: 0,
-      startTime: Date.now()
-    };
-  }
-
-  /**
-   * 销毁
-   */
-  destroy() {
-    this.cachedExecutor.destroy();
-  }
-}
-
-/**
- * 创建优化的MCP执行器
- * 
- * @example
- * const executor = createOptimizedExecutor(client, {
- *   batchSize: 10,
- *   maxConcurrent: 20,
- *   maxRetries: 3
- * });
- * 
- * // 普通调用
- * const result = await executor.callTool('my_tool', { arg: 'value' });
- * 
- * // 批量调用
- * await executor.callTool('tool1', {}, { batch: true });
- * await executor.callTool('tool2', {}, { batch: true });
- * 
- * // 缓存调用
- * const schema = await executor.callTool('get_schema', {}, { cacheable: true });
- */
-export function createOptimizedExecutor(client, options = {}) {
-  return new OptimizedMCPExecutor(client, options);
-}
-
-// 导出所有优化器
-export { BatchToolExecutor } from './batch-optimizer.mjs';
-export { RetryManager, withRetry } from './retry-optimizer.mjs';
-export { ConcurrencyLimiter, AdaptiveConcurrencyManager } from './concurrency-optimizer.mjs';
-export { ResourceCache, CachedToolExecutor } from './cache-optimizer.mjs';

package/src/optimizers/ppt-optimizer.mjs

@@ -1,263 +0,0 @@
-/**
- * PPT 场景专用 MCP 2.0 优化器
- * 
- * 针对 PPT 工作台的特定使用模式优化：
- * - 频繁状态查询 → 多级缓存
- * - 批量元素操作 → 智能批量
- * - 长时间设计操作 → 流式进度
- * - 编辑后刷新 → 智能失效
- */
-
-export class PPTOptimizedExecutor {
-  constructor(client, options = {}) {
-    this.client = client;
-    
-    // PPT 多级缓存
-    this.caches = {
-      schema: { map: new Map(), ttl: 3600000 },      // 1小时 - 能力/模板
-      document: { map: new Map(), ttl: 300000 },     // 5分钟 - 文档信息
-      elements: { map: new Map(), ttl: 30000 }       // 30秒 - 元素信息
-    };
-    
-    // 批量队列
-    this.batchQueue = [];
-    this.batchTimer = null;
-    
-    // 统计
-    this.stats = {
-      queries: 0,
-      edits: 0,
-      designs: 0,
-      cacheHits: 0,
-      batched: 0
-    };
-  }
-
-  /**
-   * 智能工具调用
-   */
-  async callTool(name, args, options = {}) {
-    const toolType = this._identifyToolType(name);
-    
-    switch (toolType) {
-      case 'query':
-        return this._handleQuery(name, args, options);
-      case 'edit':
-        return this._handleEdit(name, args, options);
-      case 'design':
-        return this._handleDesign(name, args, options);
-      default:
-        return this._handleGeneric(name, args, options);
-    }
-  }
-
-  /**
-   * 查询操作 - 多级缓存
-   */
-  async _handleQuery(name, args, options) {
-    this.stats.queries++;
-    
-    // 选择缓存级别
-    const cacheLevel = this._getCacheLevel(name);
-    const cache = this.caches[cacheLevel];
-    const cacheKey = `${name}:${JSON.stringify(args)}`;
-    
-    // 检查缓存
-    if (cache.map.has(cacheKey)) {
-      const cached = cache.map.get(cacheKey);
-      if (Date.now() - cached.timestamp < cache.ttl) {
-        this.stats.cacheHits++;
-        return cached.data;
-      }
-      cache.map.delete(cacheKey);
-    }
-    
-    // 请求数据
-    const result = await this.client.request('tools/call', {
-      name,
-      arguments: args
-    });
-    
-    // 存入缓存
-    cache.map.set(cacheKey, {
-      data: result,
-      timestamp: Date.now()
-    });
-    
-    return result;
-  }
-
-  /**
-   * 编辑操作 - 批量优化
-   */
-  async _handleEdit(name, args, options) {
-    this.stats.edits++;
-    
-    // 批量模式
-    if (options.batch !== false) {
-      this.stats.batched++;
-      return this._batchEdit(name, args);
-    }
-    
-    // 单个编辑
-    const result = await this.client.request('tools/call', {
-      name,
-      arguments: args
-    });
-    
-    // 失效缓存
-    this._invalidateCache(name);
-    
-    return result;
-  }
-
-  /**
-   * 设计操作 - 进度反馈
-   */
-  async _handleDesign(name, args, options) {
-    this.stats.designs++;
-    
-    // 带进度
-    if (options.onProgress) {
-      const interval = setInterval(() => {
-        options.onProgress({ status: 'processing' });
-      }, 1000);
-      
-      try {
-        const result = await this.client.request('tools/call', {
-          name,
-          arguments: args
-        });
-        clearInterval(interval);
-        options.onProgress({ status: 'complete', progress: 100 });
-        return result;
-      } catch (error) {
-        clearInterval(interval);
-        options.onProgress({ status: 'error' });
-        throw error;
-      }
-    }
-    
-    return this.client.request('tools/call', { name, arguments: args });
-  }
-
-  /**
-   * 通用操作
-   */
-  async _handleGeneric(name, args, options) {
-    return this.client.request('tools/call', {
-      name,
-      arguments: args
-    });
-  }
-
-  /**
-   * 批量编辑
-   */
-  async _batchEdit(name, args) {
-    return new Promise((resolve, reject) => {
-      this.batchQueue.push({ name, args, resolve, reject });
-      
-      if (!this.batchTimer) {
-        this.batchTimer = setTimeout(() => this._flushBatch(), 50);
-      }
-    });
-  }
-
-  async _flushBatch() {
-    this.batchTimer = null;
-    if (this.batchQueue.length === 0) return;
-    
-    const batch = this.batchQueue.splice(0);
-    
-    // 并行执行
-    const results = await Promise.allSettled(
-      batch.map(item => 
-        this.client.request('tools/call', {
-          name: item.name,
-          arguments: item.args
-        })
-      )
-    );
-    
-    // 失效缓存
-    this._invalidateCache('batch');
-    
-    // 分发结果
-    batch.forEach((item, i) => {
-      if (results[i].status === 'fulfilled') {
-        item.resolve(results[i].value);
-      } else {
-        item.reject(results[i].reason);
-      }
-    });
-  }
-
-  /**
-   * 识别工具类型
-   */
-  _identifyToolType(name) {
-    if (name.startsWith('ppt_get_') || name.startsWith('ppt_list_')) {
-      return 'query';
-    }
-    if (name.startsWith('ppt_add_') || name.startsWith('ppt_update_') || 
-        name.startsWith('ppt_delete_') || name.startsWith('ppt_set_')) {
-      return 'edit';
-    }
-    if (name.includes('design') || name.includes('layout') || name.includes('format')) {
-      return 'design';
-    }
-    return 'generic';
-  }
-
-  /**
-   * 确定缓存级别
-   */
-  _getCacheLevel(name) {
-    if (name.includes('capabilities') || name.includes('template')) {
-      return 'schema';
-    }
-    if (name.includes('element') || name.includes('selection')) {
-      return 'elements';
-    }
-    return 'document';
-  }
-
-  /**
-   * 失效缓存
-   */
-  _invalidateCache(name) {
-    // 编辑操作清除元素缓存
-    if (name.includes('add') || name.includes('update') || name.includes('delete')) {
-      this.caches.elements.map.clear();
-    }
-    // 幻灯片操作清除文档缓存
-    if (name.includes('slide') && !name.includes('element')) {
-      this.caches.document.map.clear();
-    }
-  }
-
-  /**
-   * 统计信息
-   */
-  getStats() {
-    const total = this.stats.queries + this.stats.edits + this.stats.designs;
-    return {
-      total,
-      queries: this.stats.queries,
-      edits: this.stats.edits,
-      designs: this.stats.designs,
-      cacheHits: this.stats.cacheHits,
-      batched: this.stats.batched,
-      cacheHitRate: total > 0 ? (this.stats.cacheHits / total * 100).toFixed(1) + '%' : '0%',
-      batchRate: this.stats.edits > 0 ? (this.stats.batched / this.stats.edits * 100).toFixed(1) + '%' : '0%'
-    };
-  }
-}
-
-/**
- * 创建 PPT 优化执行器
- */
-export function createPPTOptimizer(client, options = {}) {
-  return new PPTOptimizedExecutor(client, options);
-}