@nahisaho/shikigami-mcp-server 1.7.0 → 1.10.0

package/src/tools/search/recovery/logger.ts

@@ -0,0 +1,351 @@
+/**
+ * RecoveryLogger - フォールバックログ統計・警告機能
+ *
+ * TSK-1-001: RecoveryLogger実装
+ * REQ-SRCH-005-03: フォールバックログ
+ * DES-SRCH-005-03: RecoveryLogger設計
+ */
+
+import type { RecoveryLogEntry } from './types.js';
+
+/**
+ * 戦略別統計
+ */
+export interface StrategyStats {
+  /** 戦略名 */
+  strategy: string;
+  /** 試行回数 */
+  attempts: number;
+  /** 成功回数 */
+  successCount: number;
+  /** 成功率 */
+  successRate: number;
+  /** 平均処理時間（ms） */
+  avgDurationMs: number;
+}
+
+/**
+ * クエリ失敗情報
+ */
+export interface QueryFailureInfo {
+  /** クエリ文字列 */
+  query: string;
+  /** 失敗回数 */
+  failureCount: number;
+  /** 最後の失敗日時 */
+  lastFailure: Date;
+  /** 試行した戦略一覧 */
+  strategies: string[];
+}
+
+/**
+ * リカバリー統計
+ */
+export interface RecoveryStats {
+  /** 総試行回数 */
+  totalAttempts: number;
+  /** 成功回数 */
+  successCount: number;
+  /** 失敗回数 */
+  failureCount: number;
+  /** 成功率 */
+  successRate: number;
+  /** 平均処理時間（ms） */
+  avgDurationMs: number;
+  /** 戦略別統計 */
+  byStrategy: Record<string, StrategyStats>;
+  /** 高頻度失敗クエリ */
+  highFrequencyFailures: QueryFailureInfo[];
+  /** 統計期間開始 */
+  periodStart: Date;
+  /** 統計期間終了 */
+  periodEnd: Date;
+}
+
+/**
+ * 拡張ログエントリ（処理時間を含む）
+ */
+export interface ExtendedLogEntry extends RecoveryLogEntry {
+  /** 一意のID */
+  id: string;
+  /** リカバリータイプ */
+  type?: 'search' | 'visit';
+  /** 処理時間（ms） */
+  durationMs: number;
+  /** エラーメッセージ（失敗時） */
+  error?: string;
+  /** 代替クエリの信頼度 */
+  confidence?: number;
+}
+
+/**
+ * ロガー設定
+ */
+export interface RecoveryLoggerConfig {
+  /** 統計出力間隔（試行回数） */
+  statsInterval: number;
+  /** 高頻度失敗警告閾値 */
+  warnThreshold: number;
+  /** 最大ログエントリ保持数 */
+  maxEntries: number;
+  /** 統計集計期間（ms） */
+  statsPeriodMs: number;
+}
+
+/**
+ * デフォルト設定
+ */
+export const DEFAULT_LOGGER_CONFIG: RecoveryLoggerConfig = {
+  statsInterval: 100,
+  warnThreshold: 5,
+  maxEntries: 1000,
+  statsPeriodMs: 24 * 60 * 60 * 1000, // 24時間
+};
+
+/**
+ * リカバリーログ管理クラス
+ *
+ * フォールバック試行のログ記録、統計計算、高頻度失敗クエリの検出を行う
+ */
+export class RecoveryLogger {
+  private readonly entries: ExtendedLogEntry[] = [];
+  private readonly config: RecoveryLoggerConfig;
+  private readonly queryFailureMap: Map<string, QueryFailureInfo> = new Map();
+  private attemptCount = 0;
+  private idCounter = 0;
+
+  constructor(config?: Partial<RecoveryLoggerConfig>) {
+    this.config = { ...DEFAULT_LOGGER_CONFIG, ...config };
+  }
+
+  /**
+   * UUIDライクなIDを生成
+   */
+  private generateId(): string {
+    this.idCounter++;
+    const timestamp = Date.now().toString(36);
+    const counter = this.idCounter.toString(36).padStart(4, '0');
+    return `${timestamp}-${counter}`;
+  }
+
+  /**
+   * ログエントリを記録
+   */
+  log(entry: Omit<ExtendedLogEntry, 'id'>): void {
+    const fullEntry: ExtendedLogEntry = {
+      ...entry,
+      id: this.generateId(),
+    };
+
+    this.entries.push(fullEntry);
+    this.attemptCount++;
+
+    // 最大エントリ数を超えたら古いものを削除
+    if (this.entries.length > this.config.maxEntries) {
+      this.entries.shift();
+    }
+
+    // 失敗マップを更新
+    if (!entry.success) {
+      this.updateFailureMap(entry);
+    }
+
+    // 定期的に統計を出力
+    if (this.attemptCount % this.config.statsInterval === 0) {
+      this.outputStats();
+    }
+
+    // 高頻度失敗をチェック
+    this.checkHighFrequencyFailures(entry.originalQuery);
+  }
+
+  /**
+   * 失敗マップを更新
+   */
+  private updateFailureMap(entry: Omit<ExtendedLogEntry, 'id'>): void {
+    const existing = this.queryFailureMap.get(entry.originalQuery);
+
+    if (existing) {
+      existing.failureCount++;
+      existing.lastFailure = entry.timestamp;
+      if (!existing.strategies.includes(entry.strategy)) {
+        existing.strategies.push(entry.strategy);
+      }
+    } else {
+      this.queryFailureMap.set(entry.originalQuery, {
+        query: entry.originalQuery,
+        failureCount: 1,
+        lastFailure: entry.timestamp,
+        strategies: [entry.strategy],
+      });
+    }
+  }
+
+  /**
+   * 高頻度失敗をチェックして警告
+   */
+  private checkHighFrequencyFailures(query: string): void {
+    const failure = this.queryFailureMap.get(query);
+    if (failure && failure.failureCount === this.config.warnThreshold) {
+      console.error(
+        `[RecoveryLogger] ⚠️ High frequency failure detected: "${query}" (${failure.failureCount} failures)`
+      );
+    }
+  }
+
+  /**
+   * 統計をstderrに出力
+   */
+  private outputStats(): void {
+    const stats = this.getStats();
+    console.error(
+      `[RecoveryLogger] 📊 Stats: ${stats.totalAttempts} attempts, ${(stats.successRate * 100).toFixed(1)}% success rate`
+    );
+  }
+
+  /**
+   * 統計情報を取得
+   */
+  getStats(): RecoveryStats {
+    const now = new Date();
+    const periodStart = new Date(now.getTime() - this.config.statsPeriodMs);
+
+    // 期間内のエントリをフィルタ
+    const recentEntries = this.entries.filter(
+      (e) => e.timestamp >= periodStart
+    );
+
+    if (recentEntries.length === 0) {
+      return {
+        totalAttempts: 0,
+        successCount: 0,
+        failureCount: 0,
+        successRate: 0,
+        avgDurationMs: 0,
+        byStrategy: {},
+        highFrequencyFailures: [],
+        periodStart,
+        periodEnd: now,
+      };
+    }
+
+    const successCount = recentEntries.filter((e) => e.success).length;
+    const failureCount = recentEntries.length - successCount;
+    const totalDurationMs = recentEntries.reduce(
+      (sum, e) => sum + (e.durationMs || 0),
+      0
+    );
+
+    // 戦略別統計
+    const byStrategy: Record<string, StrategyStats> = {};
+    for (const entry of recentEntries) {
+      if (!byStrategy[entry.strategy]) {
+        byStrategy[entry.strategy] = {
+          strategy: entry.strategy,
+          attempts: 0,
+          successCount: 0,
+          successRate: 0,
+          avgDurationMs: 0,
+        };
+      }
+      const stats = byStrategy[entry.strategy];
+      stats.attempts++;
+      if (entry.success) {
+        stats.successCount++;
+      }
+    }
+
+    // 戦略別の成功率と平均時間を計算
+    for (const strategyName of Object.keys(byStrategy)) {
+      const stats = byStrategy[strategyName];
+      stats.successRate = stats.attempts > 0 ? stats.successCount / stats.attempts : 0;
+
+      const strategyEntries = recentEntries.filter(
+        (e) => e.strategy === strategyName
+      );
+      const strategyDuration = strategyEntries.reduce(
+        (sum, e) => sum + (e.durationMs || 0),
+        0
+      );
+      stats.avgDurationMs =
+        strategyEntries.length > 0
+          ? strategyDuration / strategyEntries.length
+          : 0;
+    }
+
+    // 高頻度失敗クエリを取得
+    const highFrequencyFailures = this.getHighFrequencyQueries(
+      this.config.warnThreshold
+    );
+
+    return {
+      totalAttempts: recentEntries.length,
+      successCount,
+      failureCount,
+      successRate: recentEntries.length > 0 ? successCount / recentEntries.length : 0,
+      avgDurationMs:
+        recentEntries.length > 0 ? totalDurationMs / recentEntries.length : 0,
+      byStrategy,
+      highFrequencyFailures,
+      periodStart,
+      periodEnd: now,
+    };
+  }
+
+  /**
+   * 高頻度失敗クエリを取得
+   */
+  getHighFrequencyQueries(threshold?: number): QueryFailureInfo[] {
+    const minFailures = threshold ?? this.config.warnThreshold;
+    return Array.from(this.queryFailureMap.values())
+      .filter((info) => info.failureCount >= minFailures)
+      .sort((a, b) => b.failureCount - a.failureCount);
+  }
+
+  /**
+   * ログをJSON形式でエクスポート
+   */
+  exportToJson(): string {
+    const stats = this.getStats();
+    return JSON.stringify(
+      {
+        period: `${stats.periodStart.toISOString()}/${stats.periodEnd.toISOString()}`,
+        stats: {
+          totalAttempts: stats.totalAttempts,
+          successCount: stats.successCount,
+          failureCount: stats.failureCount,
+          successRate: stats.successRate,
+          avgDurationMs: stats.avgDurationMs,
+        },
+        byStrategy: stats.byStrategy,
+        highFrequencyFailures: stats.highFrequencyFailures,
+        entries: this.entries.slice(-100), // 最新100件
+      },
+      null,
+      2
+    );
+  }
+
+  /**
+   * ログエントリを取得
+   */
+  getEntries(): ExtendedLogEntry[] {
+    return [...this.entries];
+  }
+
+  /**
+   * ログをクリア
+   */
+  clear(): void {
+    this.entries.length = 0;
+    this.queryFailureMap.clear();
+    this.attemptCount = 0;
+  }
+
+  /**
+   * 試行回数を取得
+   */
+  getAttemptCount(): number {
+    return this.attemptCount;
+  }
+}

package/src/tools/search.ts

@@ -413,3 +413,215 @@ export function resetSearchInfrastructure(): void {
   healthChecker = null;
   recoveryManager = null;
 }
+
+// ============================================================
+// v1.8.0: 多言語並列検索 (REQ-SRCH-004)
+// ============================================================
+
+import type { MultilingualSearchConfig } from '../config/types.js';
+import { DEFAULT_MULTILINGUAL_SEARCH_CONFIG } from '../config/types.js';
+import { BUILTIN_DICTIONARY } from './search/recovery/strategies/translate.js';
+
+/**
+ * v1.8.0追加の翻訳辞書（自動車・素材業界用語）
+ */
+const MULTILINGUAL_DICTIONARY_V180: Record<string, string> = {
+  // 自動車業界
+  'ネオジム磁石': 'neodymium magnet',
+  '永久磁石': 'permanent magnet',
+  '重希土類': 'heavy rare earth',
+  'ジスプロシウム': 'dysprosium',
+  'テルビウム': 'terbium',
+  '磁石レスモーター': 'magnet-free motor',
+  '巻線界磁モーター': 'wound field motor',
+  
+  // 企業名
+  'プロテリアル': 'Proterial',
+  '大同特殊鋼': 'Daido Steel',
+  '信越化学': 'Shin-Etsu Chemical',
+  'TDK': 'TDK',
+  
+  // ビジネス用語
+  '脱中国依存': 'reducing China dependency',
+  '代替材料': 'alternative materials',
+  '調達': 'procurement',
+  '戦略': 'strategy',
+};
+
+/**
+ * 多言語検索結果の型定義
+ */
+export interface MultilingualSearchResult {
+  query: {
+    original: string;
+    translated: string | null;
+    detectedLanguage: 'ja' | 'en' | 'mixed';
+  };
+  results: Array<{
+    url: string;
+    title: string;
+    snippet: string;
+    sourceLanguage: 'ja' | 'en';
+    relevanceScore?: number;
+  }>;
+  metadata: {
+    totalResults: number;
+    japaneseResults: number;
+    englishResults: number;
+    duplicatesRemoved: number;
+    executionTimeMs: number;
+  };
+}
+
+/**
+ * 言語検出 (TSK-002)
+ * REQ-SRCH-004-01: 言語検出
+ */
+export function detectLanguage(query: string): 'ja' | 'en' | 'mixed' {
+  const japanesePattern = /[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF]/;
+  const hasJapanese = japanesePattern.test(query);
+  const hasAscii = /[a-zA-Z]/.test(query);
+  
+  if (hasJapanese && hasAscii) return 'mixed';
+  if (hasJapanese) return 'ja';
+  return 'en';
+}
+
+/**
+ * クエリ翻訳 (TSK-003)
+ * REQ-SRCH-004-02: クエリ翻訳
+ * v1.7.0のBUILTIN_DICTIONARYを拡張して使用
+ */
+export function translateQuery(
+  query: string,
+  customDictionary?: Record<string, string>
+): string | null {
+  // v1.7.0辞書 + v1.8.0追加辞書 + カスタム辞書をマージ
+  const dictionary: Record<string, string> = {
+    ...BUILTIN_DICTIONARY,
+    ...MULTILINGUAL_DICTIONARY_V180,
+    ...customDictionary,
+  };
+  
+  let translated = query;
+  for (const [ja, en] of Object.entries(dictionary)) {
+    translated = translated.replace(new RegExp(ja, 'g'), en);
+  }
+  
+  // 変換があった場合のみ返却
+  return translated !== query ? translated : null;
+}
+
+/**
+ * URL正規化 (TSK-004)
+ * REQ-SRCH-004-04: 結果マージと重複排除
+ */
+export function normalizeUrl(url: string): string {
+  try {
+    const u = new URL(url);
+    // 末尾スラッシュ削除
+    u.pathname = u.pathname.replace(/\/$/, '');
+    // クエリパラメータソート
+    u.searchParams.sort();
+    // トラッキングパラメータ削除
+    ['utm_source', 'utm_medium', 'utm_campaign', 'utm_content', 'utm_term', 'ref', 'fbclid', 'gclid'].forEach(p => {
+      u.searchParams.delete(p);
+    });
+    // フラグメント削除
+    u.hash = '';
+    return u.toString().toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+}
+
+/**
+ * 結果マージ・重複排除 (TSK-004)
+ * REQ-SRCH-004-04: 結果マージと重複排除
+ */
+function mergeAndDeduplicate(
+  jaResults: SearchResult[],
+  enResults: SearchResult[],
+  priorityLang: 'ja' | 'en'
+): Array<{ url: string; title: string; snippet: string; sourceLanguage: 'ja' | 'en' }> {
+  const seen = new Map<string, { url: string; title: string; snippet: string; sourceLanguage: 'ja' | 'en' }>();
+  
+  // 優先言語の結果を先に処理
+  const first = priorityLang === 'ja' ? jaResults : enResults;
+  const firstLang = priorityLang;
+  const second = priorityLang === 'ja' ? enResults : jaResults;
+  const secondLang: 'ja' | 'en' = priorityLang === 'ja' ? 'en' : 'ja';
+  
+  for (const r of first) {
+    const normalized = normalizeUrl(r.url);
+    if (!seen.has(normalized)) {
+      seen.set(normalized, { ...r, sourceLanguage: firstLang });
+    }
+  }
+  
+  for (const r of second) {
+    const normalized = normalizeUrl(r.url);
+    if (!seen.has(normalized)) {
+      seen.set(normalized, { ...r, sourceLanguage: secondLang });
+    }
+  }
+  
+  return Array.from(seen.values());
+}
+
+/**
+ * 多言語並列検索 (TSK-005)
+ * REQ-SRCH-004-03: 並列検索実行
+ * 
+ * 設定で`multilingualSearch.enabled: true`の場合に使用
+ */
+export async function searchMultilingual(
+  query: string,
+  config?: Partial<MultilingualSearchConfig>
+): Promise<MultilingualSearchResult> {
+  const startTime = Date.now();
+  
+  // 設定をマージ
+  const mergedConfig: Required<MultilingualSearchConfig> = {
+    ...DEFAULT_MULTILINGUAL_SEARCH_CONFIG,
+    ...config,
+  };
+  
+  const detectedLang = detectLanguage(query);
+  const translatedQuery = detectedLang === 'ja' || detectedLang === 'mixed'
+    ? translateQuery(query, mergedConfig.customDictionary)
+    : null;
+  
+  // 並列検索実行
+  const [jaResultsSettled, enResultsSettled] = await Promise.allSettled([
+    searchDuckDuckGo(query, mergedConfig.maxResults),
+    translatedQuery 
+      ? searchDuckDuckGo(translatedQuery, mergedConfig.maxResults) 
+      : Promise.resolve([]),
+  ]);
+  
+  const jaResults = jaResultsSettled.status === 'fulfilled' ? jaResultsSettled.value : [];
+  const enResults = enResultsSettled.status === 'fulfilled' ? enResultsSettled.value : [];
+  
+  // 結果マージ・重複排除
+  const merged = mergeAndDeduplicate(jaResults, enResults, mergedConfig.priorityLanguage);
+  
+  const executionTimeMs = Date.now() - startTime;
+  const duplicatesRemoved = (jaResults.length + enResults.length) - merged.length;
+  
+  return {
+    query: {
+      original: query,
+      translated: translatedQuery,
+      detectedLanguage: detectedLang,
+    },
+    results: merged,
+    metadata: {
+      totalResults: merged.length,
+      japaneseResults: jaResults.length,
+      englishResults: enResults.length,
+      duplicatesRemoved,
+      executionTimeMs,
+    },
+  };
+}