poker-mcp 1.0.0

package/config/poker_mcp.code-workspace

@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {}
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "poker-mcp",
+  "version": "1.0.0",
+  "description": "YAML-based input file management tool for radiation shielding calculation code POKER with MCP support",
+  "main": "src/mcp_server_stdio_v4.js",
+  "type": "module",
+  "bin": {
+    "poker-mcp": "src/mcp_server_stdio_v4.js"
+  },
+  "scripts": {
+    "start": "node src/mcp_server_stdio_v4.js",
+    "dev": "nodemon src/mcp_server_stdio_v4.js",
+    "prepare": "echo 'NPX ready: npx poker-mcp'"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "yaml",
+    "radiation",
+    "shielding",
+    "nuclear",
+    "radioisotope",
+    "medical",
+    "accelerator",
+    "POKER",
+    "physics",
+    "validation",
+    "npx",
+    "point-kernel"
+  ],
+  "author": "Yoshihiro Hirao <tora@pointkernel.com>",
+  "license": "ISC",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.7.0",
+    "content-type": "^1.0.5",
+    "cors": "^2.8.5",
+    "express": "^5.0.1",
+    "js-yaml": "^4.1.0",
+    "raw-body": "^3.0.0",
+    "winston": "^3.17.0",
+    "zod": "^3.24.2"
+  },
+  "files": [
+    "src/",
+    "config/",
+    "README.md"
+  ]
+}

package/src/config/ConfigManager.js

@@ -0,0 +1,120 @@
+// src/config/ConfigManager.js
+import fs from 'fs/promises';
+import path from 'path';
+import { logger } from '../utils/logger.js';
+import { DataError } from '../utils/errors.js';
+
+export class ConfigManager {
+  constructor() {
+    this.config = null;
+    this.configPath = 'src/config/default.json';
+    this.userConfigPath = 'config.json';
+  }
+
+  async load() {
+    try {
+      // デフォルト設定を読み込み
+      const defaultConfig = await this.loadJsonFile(this.configPath);
+      
+      // ユーザー設定があれば読み込んでマージ
+      let userConfig = {};
+      try {
+        userConfig = await this.loadJsonFile(this.userConfigPath);
+        logger.info('ユーザー設定をロードしました', { path: this.userConfigPath });
+      } catch (error) {
+        if (error.code !== 'ENOENT') {
+          logger.warn('ユーザー設定の読み込みに失敗しました', { error: error.message });
+        }
+      }
+
+      // 環境変数でオーバーライド
+      this.config = this.mergeConfigs(defaultConfig, userConfig);
+      this.applyEnvironmentOverrides();
+
+      logger.info('設定を読み込みました', { 
+        port: this.config.server.port,
+        logLevel: this.config.logging.level 
+      });
+
+    } catch (error) {
+      logger.error('設定の読み込みに失敗しました', { error: error.message });
+      throw new DataError('設定の読み込みに失敗しました', 'CONFIG_LOAD');
+    }
+  }
+
+  async loadJsonFile(filePath) {
+    const content = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(content);
+  }
+  mergeConfigs(defaultConfig, userConfig) {
+    return this.deepMerge(defaultConfig, userConfig);
+  }
+
+  deepMerge(target, source) {
+    const result = { ...target };
+    
+    for (const key in source) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        result[key] = this.deepMerge(target[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    
+    return result;
+  }
+
+  applyEnvironmentOverrides() {
+    // 環境変数による設定オーバーライド
+    if (process.env.PORT) {
+      this.config.server.port = parseInt(process.env.PORT);
+    }
+    
+    if (process.env.LOG_LEVEL) {
+      this.config.logging.level = process.env.LOG_LEVEL;
+    }
+    
+    if (process.env.MAX_BACKUPS) {
+      this.config.data.maxBackups = parseInt(process.env.MAX_BACKUPS);
+    }
+  }
+
+  get(path, defaultValue = undefined) {
+    return this.getByPath(this.config, path, defaultValue);
+  }
+
+  getByPath(obj, path, defaultValue) {
+    const keys = path.split('.');
+    let result = obj;
+    
+    for (const key of keys) {
+      if (result && typeof result === 'object' && key in result) {
+        result = result[key];
+      } else {
+        return defaultValue;
+      }
+    }
+    
+    return result;
+  }
+
+  // よく使う設定のゲッター
+  getServerConfig() {
+    return this.config.server;
+  }
+
+  getDataConfig() {
+    return this.config.data;
+  }
+
+  getLoggingConfig() {
+    return this.config.logging;
+  }
+
+  getMaterialProperties() {
+    return this.config.physics.materials;
+  }
+}
+
+// シングルトンインスタンス
+export const configManager = new ConfigManager();

package/src/config/default.json

@@ -0,0 +1,62 @@
+{
+  "server": {
+    "port": 3001,
+    "host": "localhost",
+    "cors": {
+      "enabled": true,
+      "origins": ["*"]
+    }
+  },
+  "data": {
+    "yamlFile": "tasks/poker.yaml",
+    "pendingFile": "tasks/pending_changes.json",
+    "backupDir": "backups",
+    "maxBackups": 10
+  },
+  "logging": {
+    "level": "info",
+    "maxFiles": 5,
+    "maxSize": "10m",
+    "datePattern": "YYYY-MM-DD"
+  },
+  "physics": {
+    "materials": {
+      "Concrete": {
+        "densityRange": { "min": 1.8, "max": 2.5 },
+        "type": "structural",
+        "description": "一般的なコンクリート",
+        "defaultDensity": 2.1
+      },
+      "Heavy_concrete_T": {
+        "densityRange": { "min": 3.5, "max": 4.2 },
+        "type": "shielding", 
+        "description": "重コンクリート（タングステン系）",
+        "defaultDensity": 3.86
+      },
+      "Iron": {
+        "densityRange": { "min": 7.6, "max": 7.9 },
+        "type": "metal",
+        "description": "鉄",
+        "defaultDensity": 7.8
+      },
+      "Lead": {
+        "densityRange": { "min": 11.0, "max": 11.4 },
+        "type": "heavy_metal", 
+        "description": "鉛",
+        "defaultDensity": 11.0
+      },
+      "Water": {
+        "densityRange": { "min": 0.95, "max": 1.05 },
+        "type": "liquid",
+        "description": "水",
+        "defaultDensity": 1.0
+      },
+      "Air": {
+        "densityRange": { "min": 0.001, "max": 0.002 },
+        "type": "gas",
+        "description": "空気", 
+        "defaultDensity": 0.001205
+      }
+    }
+  }
+}

package/src/mcp/handlers/bodyHandlers.js

@@ -0,0 +1,63 @@
+// mcp/handlers/bodyHandlers.js
+import { validateBodyRequest } from '../middleware/requestValidator.js';
+import { ValidationError } from '../../utils/errors.js';
+import { logger } from '../../utils/logger.js';
+
+export function createBodyHandlers(taskManager) {
+  return {
+    async proposeBody(args) {
+      try {
+        validateBodyRequest(args);
+        const result = await taskManager.proposeBody(args.name, args.type, args);
+        return { success: true, message: result };
+      } catch (error) {
+        logger.error('proposeBodyハンドラーエラー', { args, error: error.message });
+        
+        // CMB専用エラーハンドリング
+        if (error.message && (
+          error.message.includes('演算式で参照されている立体が存在しません') ||
+          error.message.includes('循環参照が検出されました') ||
+          error.message.includes('禁止された演算子') ||
+          error.message.includes('括弧が正しく対応していません') ||
+          error.message.includes('CMB演算式は空にできません') ||
+          error.message.includes('参照が複雑すぎます')
+        )) {
+          return {
+            success: false,
+            error: error.message,
+            details: {
+              field: error.field || 'expression',
+              value: error.value,
+              type: 'CMB_VALIDATION_ERROR'
+            }
+          };
+        }
+        
+        throw error;
+      }
+    },
+
+    async updateBody(args) {
+      try {
+        if (!args.name) throw new ValidationError('立体名は必須です', 'name', args.name);
+        const { name, ...updates } = args;
+        const result = await taskManager.updateBody(name, updates);
+        return { success: true, message: result };
+      } catch (error) {
+        logger.error('updateBodyハンドラーエラー', { args, error: error.message });
+        throw error;
+      }
+    },
+
+    async deleteBody(args) {
+      try {
+        if (!args.name) throw new ValidationError('立体名は必須です', 'name', args.name);
+        const result = await taskManager.deleteBody(args.name);
+        return { success: true, message: result };
+      } catch (error) {
+        logger.error('deleteBodyハンドラーエラー', { args, error: error.message });
+        throw error;
+      }
+    }
+  };
+}

package/src/mcp/handlers/buildupFactorHandlers.js

@@ -0,0 +1,43 @@
+// mcp/handlers/buildupFactorHandlers.js
+import { validateBuildupFactorRequest } from '../middleware/requestValidator.js';
+import { ValidationError } from '../../utils/errors.js';
+
+export function createBuildupFactorHandlers(taskManager) {
+  return {
+    async proposeBuildupFactor(args) {
+      validateBuildupFactorRequest(args);
+      
+      // 必須パラメータとして扱い
+      if (args.use_slant_correction === undefined || args.use_finite_medium_correction === undefined) {
+        throw new ValidationError('use_slant_correction と use_finite_medium_correction は必須パラメータです');
+      }
+      
+      const result = await taskManager.proposeBuildupFactor(
+        args.material, 
+        args.use_slant_correction, 
+        args.use_finite_medium_correction
+      );
+      return { success: true, message: result };
+    },
+
+    async updateBuildupFactor(args) {
+      if (!args.material) throw new ValidationError('材料名は必須です', 'material', args.material);
+      const { material, ...updates } = args;
+      const result = await taskManager.updateBuildupFactor(material, updates);
+      return { success: true, message: result };
+    },
+
+    async deleteBuildupFactor(args) {
+      if (!args.material) throw new ValidationError('材料名は必須です', 'material', args.material);
+      const result = await taskManager.deleteBuildupFactor(args.material);
+      return { success: true, message: result };
+    },
+
+    async changeOrderBuildupFactor(args) {
+      if (!args.material) throw new ValidationError('材料名は必須です', 'material', args.material);
+      if (typeof args.newIndex !== 'number') throw new ValidationError('新しいインデックスは数値です', 'newIndex', args.newIndex);
+      const result = await taskManager.changeOrderBuildupFactor(args.material, args.newIndex);
+      return { success: true, message: result };
+    }
+  };
+}

package/src/mcp/handlers/calculationHandlers.js

@@ -0,0 +1,265 @@
+// mcp/handlers/calculationHandlers.js
+import { CalculationService } from '../../services/CalculationService.js';
+import { ValidationError, CalculationError } from '../../utils/errors.js';
+import { logger } from '../../utils/logger.js';
+import path from 'path';
+
+export function createCalculationHandlers(taskManager) {
+  const calculationService = new CalculationService();
+
+  return {
+    async executeCalculation(args) {
+      try {
+        // 引数検証
+        if (!args.yaml_file) {
+          throw new ValidationError('YAML file is required', 'yaml_file', args.yaml_file);
+        }
+
+        // 絶対パス形式の事前チェック（詳細検証はサービス層で実行）
+        const absolutePathPattern = /^([a-zA-Z]:[\\\/]|\/)/;
+        if (!absolutePathPattern.test(args.yaml_file)) {
+          throw new ValidationError(
+            'YAML file must be specified with absolute path. Examples: C:\\path\\to\\file.yaml or /path/to/file.yaml',
+            'yaml_file',
+            args.yaml_file
+          );
+        }
+
+        // YAML拡張子チェック
+        if (!args.yaml_file.match(/\.(yaml|yml)$/i)) {
+          throw new ValidationError(
+            'YAML file must have .yaml or .yml extension',
+            'yaml_file',
+            args.yaml_file
+          );
+        }
+
+        // サマリーオプション検証
+        const summaryOptions = args.summary_options || {};
+        if (summaryOptions.show_source_data === false && 
+            summaryOptions.show_total_dose === false) {
+          logger.warn('Both show_source_data and show_total_dose are false, this may result in minimal output');
+        }
+
+        // 出力ファイルの自動パス解決
+        const outputFiles = args.output_files || {};
+        const resolvedOutputFiles = {};
+        
+        if (Object.keys(outputFiles).length > 0) {
+          // 入力YAMLファイルのディレクトリを取得
+          const inputDir = path.dirname(args.yaml_file);
+          
+          // 各出力ファイルの絶対パス化
+          for (const [key, fileName] of Object.entries(outputFiles)) {
+            if (fileName) {
+              // ファイル名の拡張子チェック
+              if (!fileName.match(/\.(yaml|yml)$/i)) {
+                throw new ValidationError(
+                  `Output file ${key} must have .yaml or .yml extension`,
+                  `output_files.${key}`,
+                  fileName
+                );
+              }
+              
+              // 絶対パスに解決
+              resolvedOutputFiles[key] = path.join(inputDir, fileName);
+              
+              logger.debug('Output file path resolved', {
+                key,
+                fileName,
+                inputDir,
+                resolvedPath: resolvedOutputFiles[key]
+              });
+            }
+          }
+        }
+
+        // 出力ファイル検証（従来の検証は不要、上記で実施済み）
+
+        logger.info('Starting radiation shielding calculation', {
+          yamlFile: args.yaml_file,
+          summaryOptions,
+          outputFiles: outputFiles,
+          resolvedOutputFiles
+        });
+
+        // 計算実行（絶対パス化済みの出力ファイルパスを使用）
+        const result = await calculationService.executeCalculation(
+          args.yaml_file,
+          summaryOptions,
+          resolvedOutputFiles  // 絶対パス化済み
+        );
+
+        // 出力ファイル検証（絶対パス化済みのパスを使用）
+        const fileVerification = await calculationService.verifyOutputFiles(resolvedOutputFiles);
+
+        // 成功レスポンス
+        const response = {
+          success: true,
+          message: 'Radiation shielding calculation completed successfully',
+          calculation: {
+            input_file: args.yaml_file,
+            execution_time_ms: result.executionTime,
+            timestamp: result.summary.timestamp,
+            options: result.summary.options
+          },
+          outputs: {
+            console: {
+              stdout: result.outputs.stdout ? 'Available (see details)' : 'Empty',
+              stderr: result.outputs.stderr ? 'Available (see details)' : 'Empty',
+              stdout_length: result.outputs.stdout.length,
+              stderr_length: result.outputs.stderr.length
+            },
+            files: fileVerification
+          },
+          details: {
+            stdout: result.outputs.stdout,
+            stderr: result.outputs.stderr,
+            summary_options_applied: result.summary.options,
+            poker_cui_command: 'poker_cui executed successfully'
+          }
+        };
+
+        // 出力ファイル生成の警告
+        if (!fileVerification.allFilesGenerated) {
+          response.warnings = ['Some output files were not generated. Check calculation logs for details.'];
+        }
+
+        logger.info('Calculation completed successfully', {
+          yamlFile: args.yaml_file,
+          executionTime: result.executionTime,
+          outputFiles: Object.keys(fileVerification).filter(k => k !== 'allFilesGenerated')
+        });
+
+        return response;
+
+      } catch (error) {
+        logger.error('executeCalculation handler error', { 
+          args, 
+          error: error.message,
+          errorType: error.constructor.name
+        });
+
+        // CalculationErrorの場合はMCPエラーコードも含める
+        if (error instanceof CalculationError) {
+          return {
+            success: false,
+            error: error.message,
+            error_type: error.code,
+            context: error.context,
+            mcp_error_code: error.mcpErrorCode,
+            details: {
+              category: 'calculation_error',
+              recoverable: this._isRecoverableError(error.code),
+              suggestions: this._getErrorSuggestions(error.code, error.context)
+            }
+          };
+        }
+
+        // ValidationErrorの場合
+        if (error instanceof ValidationError) {
+          return {
+            success: false,
+            error: error.message,
+            error_type: 'VALIDATION_ERROR',
+            field: error.field,
+            value: error.value,
+            mcp_error_code: -32047, // Invalid calculation parameters
+            details: {
+              category: 'parameter_error',
+              recoverable: true,
+              suggestions: ['Check parameter format and values', 'Ensure all required parameters are provided']
+            }
+          };
+        }
+
+        // その他のエラー
+        throw error;
+      }
+    },
+
+    /**
+     * エラーが回復可能かどうかを判定
+     * @param {string} errorCode エラーコード
+     * @returns {boolean} 回復可能かどうか
+     */
+    _isRecoverableError(errorCode) {
+      const recoverableErrors = [
+        'YAML_FILE_NOT_FOUND',
+        'INVALID_YAML_SYNTAX', 
+        'OUTPUT_DIRECTORY_ACCESS_DENIED',
+        'INVALID_CALCULATION_PARAMETERS'
+      ];
+      return recoverableErrors.includes(errorCode);
+    },
+
+    /**
+     * エラーに対する解決提案を生成
+     * @param {string} errorCode エラーコード
+     * @param {Object} context エラーコンテキスト
+     * @returns {Array<string>} 解決提案のリスト
+     */
+    _getErrorSuggestions(errorCode, context = {}) {
+      switch (errorCode) {
+        case 'POKER_CUI_NOT_AVAILABLE':
+          return [
+            'Install poker_cui command',
+            'Ensure poker_cui is in your system PATH',
+            'Check if poker package is properly installed'
+          ];
+
+        case 'YAML_FILE_VALIDATION_FAILED':
+          return [
+            'Use absolute path format: C:\\path\\to\\file.yaml (Windows) or /path/to/file.yaml (Unix/Linux)',
+            `Check if file exists: ${context.yamlFile}`,
+            'Ensure file has proper read permissions',
+            'Verify file has .yaml or .yml extension'
+          ];
+
+        case 'YAML_FILE_NOT_FOUND':
+          return [
+            `Check if file exists: ${context.yamlFile}`,
+            'Use absolute path to the YAML file',
+            'Ensure file has proper read permissions'
+          ];
+
+        case 'INVALID_YAML_SYNTAX':
+          return [
+            'Validate YAML syntax using a YAML validator',
+            'Check for proper indentation and structure',
+            'Ensure all required sections (body, zone, source) are present',
+            context.syntaxError ? `Fix: ${context.syntaxError}` : 'Review YAML format'
+          ];
+
+        case 'OUTPUT_DIRECTORY_ACCESS_DENIED':
+          return [
+            'Check write permissions on output directory',
+            'Create output directory if it does not exist',
+            'Use absolute paths for output files'
+          ];
+
+        case 'CALCULATION_TIMEOUT':
+          return [
+            'Simplify the calculation model to reduce computation time',
+            'Increase timeout value if calculation is expected to take longer',
+            'Check system resources (CPU, memory)'
+          ];
+
+        case 'CALCULATION_EXECUTION_FAILED':
+          return [
+            'Review calculation input parameters',
+            'Check YAML file for physics validity',
+            'Examine poker_cui output for specific error messages',
+            context.stderr ? 'Check stderr output for detailed error information' : 'Review calculation setup'
+          ];
+
+        default:
+          return [
+            'Review input parameters',
+            'Check system requirements',
+            'Consult documentation for troubleshooting'
+          ];
+      }
+    }
+  };
+}