poker-mcp 1.0.0

package/src/utils/MaterialAlternatives.js

@@ -0,0 +1,189 @@
+// utils/MaterialAlternatives.js - 材料代替マッピング機能
+import { PokerMcpError } from './mcpErrors.js';
+
+/**
+ * 材料代替マッピング管理クラス
+ * マニフェストで定義された材料代替情報を活用
+ */
+export class MaterialAlternatives {
+  // マニフェストに対応する材料代替マッピング
+  static ALTERNATIVES = {
+    'STEEL': { substitute: 'Iron', note: '一般的な構造用鋼はIronで代替' },
+    'STAINLESS_STEEL': { substitute: 'Iron', note: 'ステンレス鋼もIronで代替可能' },
+    'BRASS': { substitute: 'Copper', note: '真鍮はCopperで代替' },
+    'BRONZE': { substitute: 'Copper', note: '青銅はCopperで代替' },
+    'GLASS': { substitute: 'PyrexGlass', note: '一般ガラスはPyrexGlassで代替' },
+    'PLASTIC': { substitute: 'AcrylicResin', note: '一般プラスチックはAcrylicResinで代替' },
+    'EARTH': { substitute: 'Soil', note: '土壌はSoilで代替' },
+    'VOID_SPACE': { substitute: 'VOID', note: '真空空間はVOIDで代替' },
+    'ATMOSPHERE': { substitute: 'Air', note: '大気はAirで代替' }
+  };
+
+  // サポートされる材料一覧（マニフェストと同期）
+  static SUPPORTED_MATERIALS = [
+    'Carbon', 'Concrete', 'Iron', 'Lead', 'Aluminum',
+    'Copper', 'Tungsten', 'Air', 'Water', 'PyrexGlass',
+    'AcrylicResin', 'Polyethylene', 'Soil', 'VOID'
+  ];
+
+  /**
+   * 材料名の代替提案を取得
+   * @param {string} material - 入力された材料名
+   * @returns {Object|null} 代替情報またはnull
+   */
+  static getAlternative(material) {
+    if (!material) return null;
+    
+    // 大文字小文字を正規化
+    const normalizedMaterial = material.toUpperCase();
+    
+    return this.ALTERNATIVES[normalizedMaterial] || null;
+  }
+
+  /**
+   * 材料名のファジーマッチングによる提案
+   * @param {string} material - 入力された材料名
+   * @returns {string|null} 最も類似する材料名
+   */
+  static findSimilarMaterial(material) {
+    if (!material) return null;
+    
+    const input = material.toLowerCase();
+    
+    // 部分一致による検索
+    for (const supported of this.SUPPORTED_MATERIALS) {
+      if (supported.toLowerCase().includes(input) || 
+          input.includes(supported.toLowerCase())) {
+        return supported;
+      }
+    }
+    
+    // 代替材料名での検索
+    for (const [alt, info] of Object.entries(this.ALTERNATIVES)) {
+      if (alt.toLowerCase().includes(input) || 
+          input.includes(alt.toLowerCase())) {
+        return info.substitute;
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * 包括的な材料チェックとエラー生成
+   * @param {string} material - チェック対象材料名
+   * @param {string} fieldName - フィールド名（エラー用）
+   * @throws {PokerMcpError} サポートされていない材料の場合
+   */
+  static validateMaterialWithSuggestion(material, fieldName = 'material') {
+    if (!material) {
+      throw PokerMcpError.validationError('Material name is required', fieldName, material);
+    }
+
+    // サポートされている材料かチェック
+    if (this.SUPPORTED_MATERIALS.includes(material)) {
+      return true; // 正常
+    }
+
+    // 代替材料の提案
+    const alternative = this.getAlternative(material);
+    if (alternative) {
+      throw PokerMcpError.unsupportedMaterialWithSuggestion(
+        material,
+        alternative.substitute,
+        this.SUPPORTED_MATERIALS
+      );
+    }
+
+    // ファジーマッチングによる提案
+    const similar = this.findSimilarMaterial(material);
+    if (similar) {
+      throw PokerMcpError.unsupportedMaterialWithSuggestion(
+        material,
+        similar,
+        this.SUPPORTED_MATERIALS
+      );
+    }
+
+    // 一般的なエラー（提案なし）
+    throw PokerMcpError.validationError(
+      `Unsupported material: ${material}. Supported materials: ${this.SUPPORTED_MATERIALS.join(', ')}`,
+      fieldName,
+      material
+    );
+  }
+
+  /**
+   * 材料特性情報の取得
+   * @param {string} material - 材料名
+   * @returns {Object|null} 材料特性情報
+   */
+  static getMaterialInfo(material) {
+    if (!this.SUPPORTED_MATERIALS.includes(material)) {
+      return null;
+    }
+
+    // マニフェストの material_constraints に対応
+    const materialInfo = {
+      'Carbon': { 
+        typical_use: 'グラファイト、炭素繊維構造材',
+        shielding_properties: '軽量遮蔽材'
+      },
+      'Concrete': { 
+        typical_use: '建築構造、放射線遮蔽壁',
+        shielding_properties: '汎用遮蔽材、経済的'
+      },
+      'Iron': { 
+        typical_use: '鉄鋼構造、STEEL代替',
+        shielding_properties: '中重量遮蔽材、構造材兼用'
+      },
+      'Lead': { 
+        typical_use: '高効率遮蔽材',
+        shielding_properties: '高密度γ線遮蔽材'
+      },
+      'Aluminum': { 
+        typical_use: '軽量構造材',
+        shielding_properties: '軽量遮蔽材、耐食性'
+      },
+      'Copper': { 
+        typical_use: 'BRASS/BRONZE代替',
+        shielding_properties: '中重量遮蔽材、導電性'
+      },
+      'Tungsten': { 
+        typical_use: '超高密度遮蔽材',
+        shielding_properties: '最高密度遮蔽材'
+      },
+      'Air': { 
+        typical_use: '大気、ATMOSPHERE代替',
+        shielding_properties: '透明媒体'
+      },
+      'Water': { 
+        typical_use: '中性子減速材、冷却材',
+        shielding_properties: '中性子遮蔽材'
+      },
+      'PyrexGlass': { 
+        typical_use: 'GLASS代替、耐熱ガラス',
+        shielding_properties: '透明遮蔽材'
+      },
+      'AcrylicResin': { 
+        typical_use: 'PLASTIC代替、透明樹脂',
+        shielding_properties: '軽量透明遮蔽材'
+      },
+      'Polyethylene': { 
+        typical_use: '中性子遮蔽樹脂',
+        shielding_properties: '中性子減速・遮蔽材'
+      },
+      'Soil': { 
+        typical_use: 'EARTH代替、土壌遮蔽',
+        shielding_properties: '天然遮蔽材'
+      },
+      'VOID': { 
+        density_specification: 'prohibited',
+        typical_use: '真空、VOID_SPACE代替',
+        shielding_properties: '非遮蔽領域'
+      }
+    };
+
+    return materialInfo[material] || null;
+  }
+}

package/src/utils/errorHandler.js

@@ -0,0 +1,68 @@
+// utils/errorHandler.js
+import { logger } from './logger.js';
+import { ValidationError, PhysicsError, DataError } from './errors.js';
+
+export function handleError(error, req, res, next) {
+  const { id } = req.body || {};
+  
+  logger.error('エラーが発生しました', {
+    error: error.message,
+    stack: error.stack,
+    request: {
+      method: req.method,
+      url: req.url,
+      body: req.body
+    }
+  });
+
+  // エラータイプ別の処理
+  if (error instanceof ValidationError) {
+    return res.json({
+      jsonrpc: '2.0',
+      id: id,
+      error: {
+        code: -32602,
+        message: `入力値エラー: ${error.message}`,
+        data: {
+          field: error.field,
+          value: error.value
+        }
+      }
+    });
+  }
+
+  if (error instanceof PhysicsError) {
+    return res.json({
+      jsonrpc: '2.0',
+      id: id,
+      error: {
+        code: -32000,
+        message: `物理的制約エラー: ${error.message}`,
+        data: { type: error.code }
+      }
+    });
+  }
+
+  if (error instanceof DataError) {
+    return res.json({
+      jsonrpc: '2.0',
+      id: id,
+      error: {
+        code: -32001,
+        message: `データエラー: ${error.message}`,
+        data: { operation: error.operation }
+      }
+    });
+  }
+
+  // 予期しないエラー
+  return res.json({
+    jsonrpc: '2.0',
+    id: id,
+    error: {
+      code: -32603,
+      message: 'サーバー内部エラーが発生しました',
+      data: { timestamp: new Date().toISOString() }
+    }
+  });
+}

package/src/utils/errors.js

@@ -0,0 +1,37 @@
+// utils/errors.js
+export class ValidationError extends Error {
+  constructor(message, field = null, value = null) {
+    super(message);
+    this.name = 'ValidationError';
+    this.field = field;
+    this.value = value;
+    this.code = 'VALIDATION_ERROR';
+  }
+}
+
+export class PhysicsError extends Error {
+  constructor(message, type = 'PHYSICS_VIOLATION') {
+    super(message);
+    this.name = 'PhysicsError';
+    this.code = type;
+  }
+}
+
+export class DataError extends Error {
+  constructor(message, operation = null) {
+    super(message);
+    this.name = 'DataError';
+    this.operation = operation;
+    this.code = 'DATA_ERROR';
+  }
+}
+
+export class CalculationError extends Error {
+  constructor(message, type = 'CALCULATION_ERROR', context = {}, mcpErrorCode = null) {
+    super(message);
+    this.name = 'CalculationError';
+    this.code = type;
+    this.context = context;
+    this.mcpErrorCode = mcpErrorCode;
+  }
+}

package/src/utils/logger.js

@@ -0,0 +1,24 @@
+// utils/logger.js - MCP専用版（stdout汚染防止）
+import winston from 'winston';
+import path from 'path';
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.errors({ stack: true }),
+    winston.format.json()
+  ),
+  transports: [
+    new winston.transports.File({ 
+      filename: path.join('logs', 'error.log'), 
+      level: 'error' 
+    }),
+    new winston.transports.File({ 
+      filename: path.join('logs', 'combined.log') 
+    })
+    // Console transportは削除（MCPサーバーではstdout汚染禁止）
+  ]
+});
+
+export { logger };

package/src/utils/logger_no_color.js

@@ -0,0 +1,28 @@
+// utils/logger.js - カラーコード無効化版
+import winston from 'winston';
+import path from 'path';
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.errors({ stack: true }),
+    winston.format.json()
+  ),
+  transports: [
+    new winston.transports.File({ 
+      filename: path.join('logs', 'error.log'), 
+      level: 'error' 
+    }),
+    new winston.transports.File({ 
+      filename: path.join('logs', 'combined.log') 
+    }),
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.simple()
+      )
+    })
+  ]
+});
+
+export { logger };

package/src/utils/mcpErrors.js

@@ -0,0 +1,225 @@
+// utils/mcpErrors.js
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+
+/**
+ * Poker MCP専用エラークラス
+ * マニフェストで定義された22個のカスタムエラーコードを実装
+ */
+export class PokerMcpError extends McpError {
+  // エラーコード定数
+  static BODY_NOT_FOUND = -32001;
+  static ZONE_NOT_FOUND = -32002;
+  static DUPLICATE_NAME = -32003;
+  static INVALID_BODY_TYPE = -32004;
+  static DEPENDENCY_EXISTS = -32005;
+  static FILE_ACCESS_ERROR = -32006;
+  static VALIDATION_ERROR = -32007;
+  static BACKUP_ERROR = -32008;
+  static UNIT_ALREADY_EXISTS = -32009;
+  static UNIT_NOT_FOUND = -32010;
+  static UNIT_INCOMPLETE = -32011;
+  static UNIT_KEY_MISSING = -32012;
+  static UNIT_INVALID_VALUE = -32013;
+  static UNIT_DELETE_FORBIDDEN = -32014;
+  static UNIT_REPAIR_FAILED = -32015;
+  static UNIT_VALIDATION_FAILED = -32016;
+  static TRANSFORM_NOT_FOUND = -32017;
+  static INVALID_TRANSFORM_REFERENCE = -32018;
+  static INVALID_NAME_FORMAT_HYPHENS = -32019;
+  static NAME_FORBIDDEN_CHARACTERS = -32020;
+  static INVALID_NUCLIDE_FORMAT = -32021;
+  static NUCLIDE_FORBIDDEN_HYPHEN = -32022;
+  static ATMOSPHERE_RESERVED = -32023;
+  static ATMOSPHERE_ZONE_MANDATORY = -32024;
+  static ATMOSPHERE_ZONE_DELETE_FORBIDDEN = -32025;
+  static ATMOSPHERE_ZONE_MUST_EXIST = -32026;
+  static ATMOSPHERE_MATERIAL_REQUIRED = -32027;
+  static VOID_DENSITY_PROHIBITED = -32028;
+  static NON_VOID_DENSITY_REQUIRED = -32029;
+  static MISSING_DENSITY_PARAMETER = -32030;
+  
+  // 新しい必須パラメータエラーコード（Phase 1追加）
+  static CUTOFF_RATE_REQUIRED = -32050;
+  static SHOW_PATH_TRACE_REQUIRED = -32051;
+  static USE_SLANT_CORRECTION_REQUIRED = -32052;
+  static USE_FINITE_MEDIUM_CORRECTION_REQUIRED = -32053;
+  
+  // 材料制約強化エラーコード
+  static UNSUPPORTED_MATERIAL_WITH_SUGGESTION = -32054;
+
+  constructor(code, message, field = null, value = null) {
+    super(code, message);
+    this.field = field;
+    this.value = value;
+  }
+
+  // 便利メソッド：エラーコードから適切なエラーを生成
+  static bodyNotFound(name) {
+    return new PokerMcpError(this.BODY_NOT_FOUND, `Body not found: ${name}`, 'name', name);
+  }
+
+  static zoneNotFound(bodyName) {
+    return new PokerMcpError(this.ZONE_NOT_FOUND, `Zone not found: ${bodyName}`, 'body_name', bodyName);
+  }
+
+  static duplicateName(name, type = 'object') {
+    return new PokerMcpError(this.DUPLICATE_NAME, `Duplicate ${type} name: ${name}`, 'name', name);
+  }
+
+  static invalidBodyType(type) {
+    return new PokerMcpError(this.INVALID_BODY_TYPE, `Invalid body type: ${type}`, 'type', type);
+  }
+
+  static dependencyExists(name, dependencies) {
+    return new PokerMcpError(this.DEPENDENCY_EXISTS, `Cannot delete ${name} - dependencies exist: ${dependencies.join(', ')}`, 'name', name);
+  }
+
+  static fileAccessError(filename, operation) {
+    return new PokerMcpError(this.FILE_ACCESS_ERROR, `File access error: ${operation} failed for ${filename}`, 'filename', filename);
+  }
+
+  static validationError(message, field, value) {
+    return new PokerMcpError(this.VALIDATION_ERROR, message, field, value);
+  }
+
+  static backupError(message) {
+    return new PokerMcpError(this.BACKUP_ERROR, `Backup error: ${message}`);
+  }
+
+  static unitAlreadyExists() {
+    return new PokerMcpError(this.UNIT_ALREADY_EXISTS, 'Unit section already exists');
+  }
+
+  static unitNotFound() {
+    return new PokerMcpError(this.UNIT_NOT_FOUND, 'Unit section not found');
+  }
+
+  static unitIncomplete(missingKeys) {
+    return new PokerMcpError(this.UNIT_INCOMPLETE, `Unit section incomplete - missing keys: ${missingKeys.join(', ')}`, 'keys', missingKeys);
+  }
+
+  static unitKeyMissing(key) {
+    return new PokerMcpError(this.UNIT_KEY_MISSING, `Unit key missing: ${key}`, 'key', key);
+  }
+
+  static unitInvalidValue(key, value, validValues) {
+    return new PokerMcpError(this.UNIT_INVALID_VALUE, `Unit invalid value for ${key}: ${value}. Valid values: ${validValues.join(', ')}`, key, value);
+  }
+
+  static unitDeleteForbidden() {
+    return new PokerMcpError(this.UNIT_DELETE_FORBIDDEN, 'Unit section cannot be deleted - use update instead');
+  }
+
+  static unitRepairFailed(reason) {
+    return new PokerMcpError(this.UNIT_REPAIR_FAILED, `Unit repair failed: ${reason}`);
+  }
+
+  static unitValidationFailed(details) {
+    return new PokerMcpError(this.UNIT_VALIDATION_FAILED, `Unit validation failed: ${details}`);
+  }
+
+  static transformNotFound(name) {
+    return new PokerMcpError(this.TRANSFORM_NOT_FOUND, `Transform not found: ${name}`, 'transform', name);
+  }
+
+  static invalidTransformReference(name) {
+    return new PokerMcpError(this.INVALID_TRANSFORM_REFERENCE, `Invalid transform reference: ${name} does not exist in YAML transform section`, 'transform', name);
+  }
+
+  static invalidNameFormatHyphens(name) {
+    return new PokerMcpError(this.INVALID_NAME_FORMAT_HYPHENS, `Invalid name format - hyphens not allowed: ${name}`, 'name', name);
+  }
+
+  static nameForbiddenCharacters(name, invalidChars) {
+    return new PokerMcpError(this.NAME_FORBIDDEN_CHARACTERS, `Name contains forbidden characters: ${name} (invalid: ${invalidChars.join(', ')})`, 'name', name);
+  }
+
+  static invalidNuclideFormat(nuclide) {
+    return new PokerMcpError(this.INVALID_NUCLIDE_FORMAT, `Invalid nuclide format - use concatenated format (e.g., Cs137): ${nuclide}`, 'nuclide', nuclide);
+  }
+
+  static nuclideForbiddenHyphen(nuclide) {
+    return new PokerMcpError(this.NUCLIDE_FORBIDDEN_HYPHEN, `Nuclide contains forbidden hyphen: ${nuclide}`, 'nuclide', nuclide);
+  }
+
+  static atmosphereReserved(name) {
+    return new PokerMcpError(this.ATMOSPHERE_RESERVED, `ATMOSPHERE is reserved - cannot be used as body name: ${name}`, 'name', name);
+  }
+
+  static atmosphereZoneDeleteForbidden() {
+    return new PokerMcpError(this.ATMOSPHERE_ZONE_DELETE_FORBIDDEN, 'ATMOSPHERE zone is mandatory and cannot be deleted');
+  }
+
+  static voidDensityProhibited(density) {
+    return new PokerMcpError(this.VOID_DENSITY_PROHIBITED, `Density cannot be specified for VOID material: ${density}`, 'density', density);
+  }
+
+  static nonVoidDensityRequired(material) {
+    return new PokerMcpError(this.NON_VOID_DENSITY_REQUIRED, `Density must be specified for non-VOID materials: ${material}`, 'material', material);
+  }
+
+  static missingDensityParameter(material) {
+    return new PokerMcpError(this.MISSING_DENSITY_PARAMETER, `Missing required density parameter for physical material: ${material}`, 'density', undefined);
+  }
+
+  // 新しい必須パラメータエラー用便利メソッド
+  static cutoffRateRequired() {
+    return new PokerMcpError(this.CUTOFF_RATE_REQUIRED, 'cutoff_rate parameter is required for radiation shielding calculation accuracy', 'cutoff_rate', undefined);
+  }
+
+  static showPathTraceRequired() {
+    return new PokerMcpError(this.SHOW_PATH_TRACE_REQUIRED, 'show_path_trace parameter is required for radiation path analysis', 'show_path_trace', undefined);
+  }
+
+  static useSlantCorrectionRequired() {
+    return new PokerMcpError(this.USE_SLANT_CORRECTION_REQUIRED, 'use_slant_correction parameter is required for high-precision radiation shielding calculation', 'use_slant_correction', undefined);
+  }
+
+  static useFiniteMediumCorrectionRequired() {
+    return new PokerMcpError(this.USE_FINITE_MEDIUM_CORRECTION_REQUIRED, 'use_finite_medium_correction parameter is required for accurate boundary effect analysis', 'use_finite_medium_correction', undefined);
+  }
+
+  static unsupportedMaterialWithSuggestion(material, suggestedSubstitute, supportedList = []) {
+    const message = `Unsupported material '${material}'. Did you mean '${suggestedSubstitute}'? Supported materials: ${supportedList.join(', ')}`;
+    return new PokerMcpError(this.UNSUPPORTED_MATERIAL_WITH_SUGGESTION, message, 'material', material);
+  }
+}
+
+// エラーコードマッピング（逆引き用）
+export const ERROR_CODE_MAP = {
+  [-32001]: 'Body not found',
+  [-32002]: 'Zone not found',
+  [-32003]: 'Duplicate name',
+  [-32004]: 'Invalid body type',
+  [-32005]: 'Dependency exists',
+  [-32006]: 'File access error',
+  [-32007]: 'Validation error',
+  [-32008]: 'Backup error',
+  [-32009]: 'Unit already exists',
+  [-32010]: 'Unit not found',
+  [-32011]: 'Unit incomplete',
+  [-32012]: 'Unit key missing',
+  [-32013]: 'Unit invalid value',
+  [-32014]: 'Unit delete forbidden',
+  [-32015]: 'Unit repair failed',
+  [-32016]: 'Unit validation failed',
+  [-32017]: 'Transform not found',
+  [-32018]: 'Invalid transform reference',
+  [-32019]: 'Invalid name format - hyphens not allowed',
+  [-32020]: 'Name contains forbidden characters',
+  [-32021]: 'Invalid nuclide format - use concatenated format',
+  [-32022]: 'Nuclide contains forbidden hyphen',
+  [-32023]: 'ATMOSPHERE is reserved - cannot be used as body name',
+  [-32024]: 'ATMOSPHERE zone is mandatory and cannot be deleted',
+  [-32025]: 'Multiple ATMOSPHERE zones not allowed',
+  [-32026]: 'ATMOSPHERE zone must exist in zone section',
+  [-32027]: 'ATMOSPHERE zone material assignment required',
+  [-32028]: 'Density cannot be specified for VOID material',
+  [-32029]: 'Density must be specified for non-VOID materials',
+  [-32030]: 'Missing required density parameter for physical material',
+  [-32050]: 'cutoff_rate parameter is required',
+  [-32051]: 'show_path_trace parameter is required',
+  [-32052]: 'use_slant_correction parameter is required',
+  [-32053]: 'use_finite_medium_correction parameter is required',
+  [-32054]: 'Unsupported material with suggestion'
+};