poker-mcp 1.0.0

package/src/mcp/handlers/detectorHandlers.js

@@ -0,0 +1,201 @@
+// mcp/handlers/detectorHandlers.js
+import { ValidationError } from '../../utils/errors.js';
+import { logger } from '../../utils/logger.js';
+
+export function createDetectorHandlers(taskManager) {
+  return {
+    // 検出器提案
+    async proposeDetector(args) {
+      try {
+        const { name, origin, grid = [], show_path_trace, transform = null } = args;
+        
+        // show_path_trace が必須になったことを確認
+        if (show_path_trace === undefined) {
+          throw new ValidationError('show_path_trace は必須パラメータです');
+        }
+        
+        logger.info('検出器提案開始', { 
+          name, 
+          origin, 
+          gridCount: grid.length,
+          hasTransform: !!transform,
+          pathTrace: show_path_trace
+        });
+        
+        // DetectorValidator統合のため、TaskManagerの包括的検証を利用
+        const result = await taskManager.proposeDetector(name, origin, grid, show_path_trace, transform);
+        
+        // 検出器の分析情報を追加取得
+        const detectorData = { name, origin, grid, show_path_trace, transform };
+        const analysisResult = taskManager.analyzeDetectorStructure(detectorData);
+        
+        logger.info('検出器提案完了', { 
+          name, 
+          dimension: analysisResult.dimension,
+          complexity: analysisResult.complexity 
+        });
+        
+        return { 
+          success: true, 
+          message: result,
+          detector: {
+            name,
+            type: analysisResult.type,
+            dimension: analysisResult.dimension,
+            complexity: analysisResult.complexity,
+            origin,
+            gridDimensions: grid.length,
+            hasTransform: !!transform,
+            pathTrace: show_path_trace
+          },
+          analysis: {
+            isOptimal: analysisResult.isOptimal,
+            suggestions: analysisResult.suggestions,
+            performance: analysisResult.performance
+          }
+        };
+        
+      } catch (error) {
+        logger.error('検出器提案エラー', { args, error: error.message });
+        throw error;
+      }
+    },
+    
+    // 検出器更新
+    async updateDetector(args) {
+      try {
+        const { name, ...updates } = args;
+        
+        logger.info('検出器更新開始', { name, updates });
+        
+        // 存在確認
+        const existingDetector = taskManager.findDetectorByName(name);
+        if (!existingDetector) {
+          throw new ValidationError(`検出器 ${name} が見つかりません`, 'name', name);
+        }
+        
+        // TaskManagerの包括的更新処理を利用
+        const result = await taskManager.updateDetector(name, updates);
+        
+        // 更新後の分析情報
+        const updatedDetectorData = { ...existingDetector, ...updates };
+        const analysisResult = taskManager.analyzeDetectorStructure(updatedDetectorData);
+        
+        logger.info('検出器更新完了', { 
+          name, 
+          newComplexity: analysisResult.complexity 
+        });
+        
+        return { 
+          success: true, 
+          message: result,
+          updated: {
+            name,
+            ...updates,
+            analysisAfterUpdate: {
+              complexity: analysisResult.complexity,
+              dimension: analysisResult.dimension,
+              isOptimal: analysisResult.isOptimal
+            }
+          }
+        };
+        
+      } catch (error) {
+        logger.error('検出器更新エラー', { args, error: error.message });
+        throw error;
+      }
+    },
+    
+    // 検出器削除
+    async deleteDetector(args) {
+      try {
+        const { name } = args;
+        
+        logger.info('検出器削除開始', { name });
+        
+        // 存在確認
+        const existingDetector = taskManager.findDetectorByName(name);
+        if (!existingDetector) {
+          throw new ValidationError(`検出器 ${name} が見つかりません`, 'name', name);
+        }
+        
+        // 削除前の分析情報を記録
+        const preDeleteAnalysis = taskManager.analyzeDetectorStructure(existingDetector);
+        
+        const result = await taskManager.deleteDetector(name);
+        
+        logger.info('検出器削除完了', { 
+          name, 
+          deletedComplexity: preDeleteAnalysis.complexity 
+        });
+        
+        return { 
+          success: true, 
+          message: result,
+          deleted: {
+            name,
+            type: preDeleteAnalysis.type,
+            dimension: preDeleteAnalysis.dimension,
+            complexity: preDeleteAnalysis.complexity
+          }
+        };
+        
+      } catch (error) {
+        logger.error('検出器削除エラー', { args, error: error.message });
+        throw error;
+      }
+    },
+    
+    // 検出器互換性分析
+    async analyzeDetectorCompatibility(args) {
+      try {
+        const { detector1Name, detector2Name } = args;
+        
+        logger.info('検出器互換性分析開始', { detector1Name, detector2Name });
+        
+        const result = await taskManager.analyzeDetectorCompatibility(detector1Name, detector2Name);
+        
+        logger.info('検出器互換性分析完了', { 
+          detector1Name, 
+          detector2Name,
+          compatibility: result.compatibility.overall 
+        });
+        
+        return {
+          success: true,
+          message: `検出器互換性分析完了: ${result.compatibility.overall}`,
+          compatibility: result
+        };
+        
+      } catch (error) {
+        logger.error('検出器互換性分析エラー', { args, error: error.message });
+        throw error;
+      }
+    },
+    
+    // システム検出器性能分析
+    async analyzeSystemDetectorPerformance(args) {
+      try {
+        logger.info('システム検出器性能分析開始');
+        
+        const result = await taskManager.analyzeSystemDetectorPerformance();
+        
+        logger.info('システム検出器性能分析完了', {
+          totalDetectors: result.totalDetectors,
+          averageComplexity: result.averageComplexity,
+          totalMemoryMB: result.memoryEstimate.total
+        });
+        
+        return {
+          success: true,
+          message: `システム検出器性能分析完了: ${result.totalDetectors}個の検出器を分析`,
+          performance: result
+        };
+        
+      } catch (error) {
+        logger.error('システム検出器性能分析エラー', { error: error.message });
+        throw error;
+      }
+    }
+  };
+}

package/src/mcp/handlers/index.js

@@ -0,0 +1,43 @@
+// mcp/handlers/index.js
+import { createBodyHandlers } from './bodyHandlers.js';
+import { createZoneHandlers } from './zoneHandlers.js';
+import { createTransformHandlers } from './transformHandlers.js';
+import { createBuildupFactorHandlers } from './buildupFactorHandlers.js';
+import { createSourceHandlers } from './sourceHandlers.js';
+import { createDetectorHandlers } from './detectorHandlers.js';
+import { createUnitHandlers } from './unitHandlers.js';
+import { createCalculationHandlers } from './calculationHandlers.js';
+
+export function createAllHandlers(taskManager) {
+  return {
+    // 立体操作
+    ...createBodyHandlers(taskManager),
+    
+    // ゾーン操作
+    ...createZoneHandlers(taskManager),
+    
+    // 変換操作
+    ...createTransformHandlers(taskManager),
+    
+    // ビルドアップ係数操作
+    ...createBuildupFactorHandlers(taskManager),
+    
+    // 線源操作
+    ...createSourceHandlers(taskManager),
+    
+    // 検出器操作
+    ...createDetectorHandlers(taskManager),
+    
+    // 単位操作
+    ...createUnitHandlers(taskManager),
+    
+    // 計算操作
+    ...createCalculationHandlers(taskManager),
+    
+    // 共通操作
+    async applyChanges(args) {
+      const result = await taskManager.applyChanges();
+      return { success: true, message: '変更を適用しました', details: result };
+    }
+  };
+}

package/src/mcp/handlers/sourceHandlers.js

@@ -0,0 +1,25 @@
+// mcp/handlers/sourceHandlers.js
+import { validateSourceRequest, validateUpdateSourceRequest, validateDeleteSourceRequest } from '../middleware/requestValidator.js';
+
+export function createSourceHandlers(taskManager) {
+  return {
+    async proposeSource(args) {
+      validateSourceRequest(args);
+      const result = await taskManager.proposeSource(args);
+      return { success: true, message: result };
+    },
+    
+    async updateSource(args) {
+      validateUpdateSourceRequest(args);
+      const { name, ...updates } = args;
+      const result = await taskManager.updateSource(name, updates);
+      return { success: true, message: result };
+    },
+    
+    async deleteSource(args) {
+      validateDeleteSourceRequest(args);
+      const result = await taskManager.deleteSource(args.name);
+      return { success: true, message: result };
+    }
+  };
+}

package/src/mcp/handlers/transformHandlers.js

@@ -0,0 +1,26 @@
+// mcp/handlers/transformHandlers.js
+import { validateTransformRequest } from '../middleware/requestValidator.js';
+import { ValidationError } from '../../utils/errors.js';
+
+export function createTransformHandlers(taskManager) {
+  return {
+    async proposeTransform(args) {
+      validateTransformRequest(args);
+      const result = await taskManager.proposeTransform(args.name, args.operations);
+      return { success: true, message: result };
+    },
+
+    async updateTransform(args) {
+      if (!args.name) throw new ValidationError('変換名は必須です', 'name', args.name);
+      const { name, ...updates } = args;
+      const result = await taskManager.updateTransform(name, updates);
+      return { success: true, message: result };
+    },
+
+    async deleteTransform(args) {
+      if (!args.name) throw new ValidationError('変換名は必須です', 'name', args.name);
+      const result = await taskManager.deleteTransform(args.name);
+      return { success: true, message: result };
+    }
+  };
+}

package/src/mcp/handlers/unitHandlers.js

@@ -0,0 +1,305 @@
+// mcp/handlers/unitHandlers.js
+import { ValidationError } from '../../utils/errors.js';
+import { logger } from '../../utils/logger.js';
+
+export function createUnitHandlers(taskManager) {
+  // ヘルパー関数をローカルスコープで定義
+  function generateUnitUsageStats(integrityResult) {
+    const stats = {
+      totalUsages: 0,
+      usagesByKey: {
+        length: 0,
+        angle: 0,
+        density: 0,
+        radioactivity: 0
+      },
+      contextTypes: {
+        coordinates: 0,
+        geometry: 0,
+        material_properties: 0,
+        radiation: 0
+      }
+    };
+
+    if (integrityResult.systemIntegrity && integrityResult.systemIntegrity.usageConsistency) {
+      integrityResult.systemIntegrity.usageConsistency.forEach(usage => {
+        stats.totalUsages += usage.usageCount;
+        
+        // 使用コンテキストの分類
+        usage.contexts.forEach(context => {
+          if (context.includes('coordinates') || context.includes('position')) {
+            stats.contextTypes.coordinates++;
+          } else if (context.includes('geometry') || context.includes('edge')) {
+            stats.contextTypes.geometry++;
+          } else if (context.includes('density')) {
+            stats.contextTypes.material_properties++;
+          } else if (context.includes('radioactivity') || context.includes('inventory')) {
+            stats.contextTypes.radiation++;
+          }
+        });
+      });
+    }
+
+    return stats;
+  }
+
+  function organizeRecommendations(integrityResult) {
+    const recommendations = [];
+    
+    // 診断レポートからの推奨事項
+    if (integrityResult.diagnosticReport && integrityResult.diagnosticReport.recommendations) {
+      integrityResult.diagnosticReport.recommendations.forEach(rec => {
+        recommendations.push({
+          type: 'system_optimization',
+          priority: 'medium',
+          category: 'unit_consistency',
+          message: rec,
+          source: 'diagnostic_report'
+        });
+      });
+    }
+    
+    // 物理的整合性からの推奨事項
+    if (integrityResult.physicalConsistency && integrityResult.physicalConsistency.recommendations) {
+      integrityResult.physicalConsistency.recommendations.forEach(rec => {
+        recommendations.push({
+          type: 'physical_consistency',
+          priority: 'high',
+          category: 'unit_physics',
+          message: rec.message,
+          source: 'physical_consistency'
+        });
+      });
+    }
+    
+    // 健全性に基づく一般的推奨事項
+    const overallHealth = integrityResult.summary.overallHealth;
+    if (overallHealth === 'warning' || overallHealth === 'minor_warnings') {
+      recommendations.push({
+        type: 'health_improvement',
+        priority: 'medium',
+        category: 'system_health',
+        message: 'Consider reviewing unit system warnings to improve overall consistency',
+        source: 'health_analysis'
+      });
+    } else if (overallHealth === 'excellent') {
+      recommendations.push({
+        type: 'maintenance',
+        priority: 'low',
+        category: 'system_health', 
+        message: 'Unit system is in excellent condition. Continue current practices.',
+        source: 'health_analysis'
+      });
+    }
+    
+    return recommendations;
+  }
+
+  return {
+    // 単位設定提案（4キー完全性保証）
+    async proposeUnit(args) {
+      try {
+        const { length, angle, density, radioactivity } = args;
+        
+        logger.info('4キー完全単位設定提案開始', { length, angle, density, radioactivity });
+        
+        // TaskManagerの4キー完全性保証機能を利用
+        const result = await taskManager.proposeUnit(length, angle, density, radioactivity);
+        
+        logger.info('4キー完全単位設定提案完了', { 
+          units: { length, angle, density, radioactivity }
+        });
+        
+        return { 
+          success: true, 
+          message: result,
+          unit: {
+            length,
+            angle,
+            density,
+            radioactivity,
+            integrity: '4-key-complete'
+          }
+        };
+        
+      } catch (error) {
+        logger.error('単位設定提案エラー', { args, error: error.message });
+        throw error;
+      }
+    },
+    
+    // 単位設定取得（4キー完全性検証付き）
+    async getUnit(args) {
+      try {
+        logger.info('4キー完全単位設定取得開始');
+        
+        // TaskManagerの4キー完全性保証取得機能を利用
+        const result = await taskManager.getUnit();
+        
+        logger.info('4キー完全単位設定取得完了', { 
+          unit: result.unit,
+          integrity: result.integrity 
+        });
+        
+        return { 
+          success: true, 
+          message: '4キー完全単位設定を取得しました',
+          ...result
+        };
+        
+      } catch (error) {
+        logger.error('単位設定取得エラー', { error: error.message });
+        throw error;
+      }
+    },
+    
+    // 単位設定更新（4キー保持保証）
+    async updateUnit(args) {
+      try {
+        if (!args || Object.keys(args).length === 0) {
+          throw new ValidationError('更新する内容が指定されていません', 'updates', args);
+        }
+        
+        logger.info('4キー保持単位更新開始', { updates: args });
+        
+        // TaskManagerの4キー保持更新機能を利用
+        const result = await taskManager.updateUnit(args);
+        
+        logger.info('4キー保持単位更新完了', { 
+          updates: args
+        });
+        
+        return { 
+          success: true, 
+          message: result,
+          updated: {
+            ...args,
+            integrity: '4-key-preserved'
+          }
+        };
+        
+      } catch (error) {
+        logger.error('単位設定更新エラー', { args, error: error.message });
+        throw error;
+      }
+    },
+    
+    // 単位完全性検証
+    async validateUnitIntegrity(args) {
+      try {
+        const { includeSystemAnalysis = true, generateReport = true } = args;
+        
+        logger.info('単位完全性検証開始', { includeSystemAnalysis, generateReport });
+        
+        // TaskManagerの包括的完全性検証を利用
+        const result = await taskManager.validateUnitIntegrity(includeSystemAnalysis, generateReport);
+        
+        logger.info('単位完全性検証完了', { 
+          fourKeyComplete: result.fourKeyComplete,
+          overallHealth: result.summary.overallHealth
+        });
+        
+        return {
+          success: true,
+          message: `単位完全性検証完了 - 健全性: ${result.summary.overallHealth}`,
+          integrity: result
+        };
+        
+      } catch (error) {
+        logger.error('単位完全性検証エラー', { args, error: error.message });
+        throw error;
+      }
+    },
+    
+    // 単位変換分析
+    async analyzeUnitConversion(args) {
+      try {
+        const { targetUnits, includePhysicalAnalysis = true } = args;
+        
+        if (!targetUnits) {
+          throw new ValidationError('変換先単位系（targetUnits）は必須です', 'targetUnits', targetUnits);
+        }
+        
+        logger.info('単位変換分析開始', { targetUnits, includePhysicalAnalysis });
+        
+        // TaskManagerの変換係数分析機能を利用
+        const result = await taskManager.analyzeUnitConversion(targetUnits, includePhysicalAnalysis);
+        
+        logger.info('単位変換分析完了', { 
+          isIdentityConversion: result.conversion.isIdentity,
+          recommendationCount: result.recommendations.length
+        });
+        
+        return {
+          success: true,
+          message: `単位変換分析完了 - ${result.conversion.isIdentity ? '変換不要' : '変換が必要'}`,
+          conversion: result
+        };
+        
+      } catch (error) {
+        logger.error('単位変換分析エラー', { args, error: error.message });
+        throw error;
+      }
+    },
+    
+    // システム単位使用状況分析
+    async analyzeUnitUsage(args) {
+      try {
+        logger.info('システム単位使用状況分析開始');
+        
+        // 現在の単位設定を取得
+        const currentUnit = await taskManager.getUnit();
+        
+        // システム全体での単位使用状況を分析
+        const result = await taskManager.validateUnitIntegrity(true, true);
+        
+        // 使用状況統計を生成
+        const usageStats = generateUnitUsageStats(result);
+        
+        logger.info('システム単位使用状況分析完了', usageStats);
+        
+        return {
+          success: true,
+          message: `システム単位使用状況分析完了 - 使用箇所: ${usageStats.totalUsages}`,
+          currentUnit: currentUnit.unit,
+          usageAnalysis: usageStats,
+          systemIntegrity: result.systemIntegrity
+        };
+        
+      } catch (error) {
+        logger.error('システム単位使用状況分析エラー', { error: error.message });
+        throw error;
+      }
+    },
+    
+    // 単位推奨事項取得
+    async getUnitRecommendations(args) {
+      try {
+        logger.info('単位推奨事項取得開始');
+        
+        // 完全性診断レポートを生成
+        const integrityResult = await taskManager.validateUnitIntegrity(true, true);
+        
+        // 推奨事項を整理
+        const recommendations = organizeRecommendations(integrityResult);
+        
+        logger.info('単位推奨事項取得完了', {
+          recommendationCount: recommendations.length
+        });
+        
+        return {
+          success: true,
+          message: `単位推奨事項を${recommendations.length}件取得しました`,
+          recommendations,
+          overallHealth: integrityResult.summary.overallHealth,
+          criticalIssues: integrityResult.summary.criticalIssues,
+          warnings: integrityResult.summary.warnings
+        };
+        
+      } catch (error) {
+        logger.error('単位推奨事項取得エラー', { error: error.message });
+        throw error;
+      }
+    }
+  };
+}

package/src/mcp/handlers/zoneHandlers.js

@@ -0,0 +1,83 @@
+// mcp/handlers/zoneHandlers.js
+import { validateZoneRequest } from '../middleware/requestValidator.js';
+import { ValidationError } from '../../utils/errors.js';
+import { logger } from '../../utils/logger.js';
+
+export function createZoneHandlers(taskManager) {
+  return {
+    async proposeZone(args) {
+      try {
+        validateZoneRequest(args);
+        
+        // VOID材料での密度指定チェック
+        if (args.material === 'VOID' && args.density !== undefined) {
+          throw new ValidationError(
+            'Density cannot be specified for VOID material', 
+            'density', 
+            args.density
+          );
+        }
+
+        // 非VOID材料での密度必須チェック
+        if (args.material !== 'VOID' && args.density === undefined) {
+          throw new ValidationError(
+            'Density must be specified for non-VOID materials', 
+            'density', 
+            args.density
+          );
+        }
+
+        const result = await taskManager.proposeZone(args.body_name, args.material, args.density);
+        return { success: true, message: result };
+      } catch (error) {
+        logger.error('proposeZoneハンドラーエラー', { args, error: error.message });
+        throw error;
+      }
+    },
+
+    async updateZone(args) {
+      try {
+        if (!args.body_name) throw new ValidationError('立体名は必須です', 'body_name', args.body_name);
+        
+        // 材料更新時の密度制約チェック
+        if (args.material !== undefined) {
+          // VOID材料での密度指定チェック
+          if (args.material === 'VOID' && args.density !== undefined) {
+            throw new ValidationError(
+              'Density cannot be specified for VOID material', 
+              'density', 
+              args.density
+            );
+          }
+
+          // 非VOID材料での密度必須チェック
+          if (args.material !== 'VOID' && args.density === undefined) {
+            throw new ValidationError(
+              'Density must be specified for non-VOID materials', 
+              'density', 
+              args.density
+            );
+          }
+        }
+
+        const { body_name, ...updates } = args;
+        const result = await taskManager.updateZone(body_name, updates);
+        return { success: true, message: result };
+      } catch (error) {
+        logger.error('updateZoneハンドラーエラー', { args, error: error.message });
+        throw error;
+      }
+    },
+
+    async deleteZone(args) {
+      try {
+        if (!args.body_name) throw new ValidationError('立体名は必須です', 'body_name', args.body_name);
+        const result = await taskManager.deleteZone(args.body_name);
+        return { success: true, message: result };
+      } catch (error) {
+        logger.error('deleteZoneハンドラーエラー', { args, error: error.message });
+        throw error;
+      }
+    }
+  };
+}