@lydt/geogebra-studio 0.0.0-stage → 0.4.0-rc.2

package/src/tools/index.ts

@@ -0,0 +1,192 @@
+import { McpTool, ToolDefinition } from '../types/mcp';
+import { errors } from '../utils/errors';
+import logger from '../utils/logger';
+import { getAppInfo } from '../utils/app-info';
+import { geogebraTools } from './geogebra-tools';
+import { exportTools } from './export-tools';
+import { educationalTemplateTools } from './educational-templates';
+import { performanceTools } from './performance-tools';
+import { appsApiTools } from './apps-api-tools';
+
+// Check if we're in MCP mode (stdio communication)
+// When piping input, process.stdin.isTTY is undefined, not false
+const isMcpMode = !process.stdin.isTTY;
+const appInfo = getAppInfo();
+
+/**
+ * Tool Registry for managing MCP tools
+ */
+export class ToolRegistry {
+  private tools: Map<string, ToolDefinition> = new Map();
+
+  /**
+   * Register a new tool
+   */
+  register(definition: ToolDefinition): void {
+    const name = definition.tool.name;
+    const readOnly = ['echo', 'ping', 'server_info', 'geogebra_get_objects',
+      'geogebra_instance_status', 'geogebra_get_prompt_framework', 'geogebra_get_semantic_scene'].includes(name);
+    definition.tool.annotations ??= {
+      readOnlyHint: readOnly,
+      destructiveHint: !readOnly,
+      idempotentHint: readOnly,
+      openWorldHint: name.startsWith('geogebra_') && !['geogebra_create_html', 'geogebra_clean_tikz'].includes(name),
+    };
+    this.tools.set(name, definition);
+    if (!isMcpMode) {
+      logger.info(`Registered tool: ${definition.tool.name}`);
+    }
+  }
+
+  /**
+   * Get all registered tools
+   */
+  getTools(): McpTool[] {
+    return Array.from(this.tools.values()).map(def => def.tool);
+  }
+
+  /**
+   * Get a specific tool by name
+   */
+  getTool(name: string): ToolDefinition | undefined {
+    return this.tools.get(name);
+  }
+
+  /**
+   * Execute a tool by name with given parameters
+   */
+  async executeTool(name: string, params: Record<string, unknown> = {}) {
+    const toolDef = this.tools.get(name);
+    
+    if (!toolDef) {
+      throw errors.toolNotFound(name);
+    }
+
+    try {
+      if (!isMcpMode) {
+        logger.info(`Executing tool: ${name}`, { params });
+      }
+      const result = await toolDef.handler(params);
+      if (!isMcpMode) {
+        logger.info(`Tool execution completed: ${name}`);
+      }
+      return result;
+    } catch (error) {
+      logger.error(`Tool execution failed: ${name}`, error);
+      throw errors.toolExecutionError(name, error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  /**
+   * Check if a tool exists
+   */
+  hasTool(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  /**
+   * Get the number of registered tools
+   */
+  getToolCount(): number {
+    return this.tools.size;
+  }
+}
+
+// Create global tool registry instance
+export const toolRegistry = new ToolRegistry();
+
+// Example tools for testing and demonstration
+const exampleTools: ToolDefinition[] = [
+  {
+    tool: {
+      name: 'echo',
+      description: 'Echo back the provided message',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          message: {
+            type: 'string',
+            description: 'The message to echo back'
+          }
+        },
+        required: ['message']
+      }
+    },
+    handler: async (params: Record<string, unknown>) => {
+      const message = params['message'] as string;
+      return {
+        content: [{
+          type: 'text' as const,
+          text: `Echo: ${message}`
+        }]
+      };
+    }
+  },
+  {
+    tool: {
+      name: 'ping',
+      description: 'Simple ping tool that returns pong',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: []
+      }
+    },
+    handler: async () => {
+      return {
+        content: [{
+          type: 'text' as const,
+          text: 'pong'
+        }]
+      };
+    }
+  },
+  {
+    tool: {
+      name: 'server_info',
+      description: 'Get information about the MCP server',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: []
+      }
+    },
+    handler: async () => {
+      return {
+        content: [{
+          type: 'text' as const,
+          text: JSON.stringify({
+            name: 'GeoGebra Studio',
+            version: appInfo.version,
+            description: appInfo.description,
+            toolCount: toolRegistry.getToolCount(),
+            timestamp: new Date().toISOString()
+          }, null, 2)
+        }]
+      };
+    }
+  }
+];
+
+// Register example tools
+exampleTools.forEach(tool => {
+  toolRegistry.register(tool);
+});
+
+// Register GeoGebra tools
+geogebraTools.forEach(tool => {
+  toolRegistry.register(tool);
+});
+
+// Register Educational Template tools
+educationalTemplateTools.forEach(tool => {
+  toolRegistry.register(tool);
+});
+
+// Register Performance tools
+performanceTools.forEach(tool => {
+  toolRegistry.register(tool);
+}); 
+
+exportTools.forEach(tool => toolRegistry.register(tool));
+appsApiTools.forEach(tool => toolRegistry.register(tool));

package/src/tools/performance-tools.ts

@@ -0,0 +1,322 @@
+/**
+ * Performance Optimization Tools
+ * GEB-9: Performance Optimization: Response Time and Resource Management
+ */
+
+import { ToolDefinition } from '../types/mcp';
+import { performanceMonitor } from '../utils/performance';
+import { optimizedInstancePool } from '../utils/performance/instance-pool';
+import logger from '../utils/logger';
+
+export const performanceTools: ToolDefinition[] = [
+  {
+    tool: {
+      name: 'performance_get_stats',
+      description: 'Get performance statistics for operations',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          operationName: {
+            type: 'string',
+            description: 'Specific operation name to get stats for (optional - if not provided, gets overall stats)'
+          }
+        }
+      }
+    },
+    handler: async (params) => {
+      try {
+        const operationName = params['operationName'] as string | undefined;
+        const stats = performanceMonitor.getStats(operationName);
+        const operationNames = performanceMonitor.getOperationNames();
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              operationName: operationName || 'overall',
+              stats,
+              availableOperations: operationNames,
+              summary: {
+                totalOperations: stats.count,
+                averageResponseTime: `${stats.averageDuration.toFixed(2)}ms`,
+                successRate: `${(stats.successRate * 100).toFixed(1)}%`,
+                p95ResponseTime: `${stats.p95Duration.toFixed(2)}ms`,
+                performanceStatus: stats.p95Duration < 2000 ? 'GOOD' : 'NEEDS_ATTENTION'
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to get performance stats', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            }, null, 2)
+          }],
+          isError: true
+        };
+      }
+    }
+  },
+
+  {
+    tool: {
+      name: 'performance_get_pool_stats',
+      description: 'Get instance pool performance and resource statistics',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    },
+    handler: async () => {
+      try {
+        const poolStats = optimizedInstancePool.getStats();
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              poolStats,
+              resourceStatus: {
+                memoryUsage: `${poolStats.memoryEstimate}MB estimated`,
+                efficiency: poolStats.averageUsage > 5 ? 'HIGH' : 'NORMAL',
+                poolUtilization: `${((poolStats.activeInstances / poolStats.totalInstances) * 100).toFixed(1)}%`,
+                recommendation: poolStats.totalInstances === 0 
+                  ? 'Pool empty - instances will be created on demand'
+                  : poolStats.averageUsage > 10 
+                    ? 'Consider increasing pool size for high usage'
+                    : 'Pool size appropriate for current usage'
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to get pool stats', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            }, null, 2)
+          }],
+          isError: true
+        };
+      }
+    }
+  },
+
+  {
+    tool: {
+      name: 'performance_warm_up_pool',
+      description: 'Pre-warm the instance pool for better performance',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          count: {
+            type: 'number',
+            description: 'Number of instances to pre-create (default: 1, max: 3)',
+            minimum: 1,
+            maximum: 3
+          }
+        }
+      }
+    },
+    handler: async (params) => {
+      try {
+        const count = Math.min((params['count'] as number) || 1, 3);
+        
+        const startTime = Date.now();
+        await optimizedInstancePool.warmUp(count);
+        const duration = Date.now() - startTime;
+        
+        const poolStats = optimizedInstancePool.getStats();
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              message: `Pool warmed up with ${count} instances`,
+              warmUpTime: `${duration}ms`,
+              poolStats: {
+                totalInstances: poolStats.totalInstances,
+                memoryEstimate: `${poolStats.memoryEstimate}MB`
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to warm up pool', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            }, null, 2)
+          }],
+          isError: true
+        };
+      }
+    }
+  },
+
+  {
+    tool: {
+      name: 'performance_clear_metrics',
+      description: 'Clear all performance metrics (useful for testing)',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    },
+    handler: async () => {
+      try {
+        performanceMonitor.clearMetrics();
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              message: 'All performance metrics cleared'
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to clear metrics', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            }, null, 2)
+          }],
+          isError: true
+        };
+      }
+    }
+  },
+
+  {
+    tool: {
+      name: 'performance_benchmark',
+      description: 'Run performance benchmark tests',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          testType: {
+            type: 'string',
+            description: 'Type of benchmark to run',
+            enum: ['basic', 'command_execution', 'export_operations', 'all']
+          },
+          iterations: {
+            type: 'number',
+            description: 'Number of iterations to run (default: 5)',
+            minimum: 1,
+            maximum: 20
+          }
+        },
+        required: ['testType']
+      }
+    },
+    handler: async (params) => {
+      try {
+        const testType = params['testType'] as string;
+        const iterations = Math.min((params['iterations'] as number) || 5, 20);
+        
+        const benchmarkResults: any = {
+          testType,
+          iterations,
+          results: [],
+          summary: {}
+        };
+
+        const instance = await optimizedInstancePool.getInstance();
+        
+        try {
+          if (testType === 'basic' || testType === 'all') {
+            // Basic command execution benchmark
+            const durations: number[] = [];
+            for (let i = 0; i < iterations; i++) {
+              const startTime = Date.now();
+              await instance.evalCommand(`TestPoint${i} = (${i}, ${i})`);
+              durations.push(Date.now() - startTime);
+            }
+            
+            benchmarkResults.results.push({
+              operation: 'basic_command_execution',
+              durations,
+              average: durations.reduce((a, b) => a + b, 0) / durations.length,
+              min: Math.min(...durations),
+              max: Math.max(...durations)
+            });
+          }
+
+          if (testType === 'export_operations' || testType === 'all') {
+            // Export benchmark
+            await instance.evalCommand('A = (0, 0)');
+            await instance.evalCommand('B = (1, 1)');
+            await instance.evalCommand('line1 = Line(A, B)');
+            
+            const exportDurations: number[] = [];
+            for (let i = 0; i < Math.min(iterations, 3); i++) { // Limit export tests
+              const startTime = Date.now();
+              await instance.exportSVG();
+              exportDurations.push(Date.now() - startTime);
+            }
+            
+            benchmarkResults.results.push({
+              operation: 'svg_export',
+              durations: exportDurations,
+              average: exportDurations.reduce((a, b) => a + b, 0) / exportDurations.length,
+              min: Math.min(...exportDurations),
+              max: Math.max(...exportDurations)
+            });
+          }
+
+          // Calculate overall summary
+          benchmarkResults.summary = {
+            totalTests: benchmarkResults.results.length,
+            allTestsPassed: benchmarkResults.results.every((r: any) => r.average < 2000),
+            recommendedAction: benchmarkResults.results.some((r: any) => r.average > 1500) 
+              ? 'Consider pool warm-up or optimization' 
+              : 'Performance is within acceptable range'
+          };
+
+        } finally {
+          await optimizedInstancePool.releaseInstance(instance);
+        }
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              benchmark: benchmarkResults
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to run benchmark', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            }, null, 2)
+          }],
+          isError: true
+        };
+      }
+    }
+  }
+];