kiri-mcp-server 0.5.0 → 0.7.0

package/dist/src/server/handlers.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { generateEmbedding, structuralSimilarity } from "../shared/embedding.js";
-import { encode as encodeGPT } from "../shared/tokenizer.js";
+import { encode as encodeGPT, tokenizeText } from "../shared/tokenizer.js";
 import { coerceProfileName, loadScoringProfile } from "./scoring.js";
 const DEFAULT_SEARCH_LIMIT = 50;
 const DEFAULT_SNIPPET_WINDOW = 150;
@@ -73,22 +73,125 @@ function normalizeBundleLimit(limit) {
     }
     return Math.min(Math.max(1, Math.floor(limit)), MAX_BUNDLE_LIMIT);
 }
+/**
+ * トークン化戦略を取得
+ * 環境変数またはデフォルト値から決定
+ */
+function getTokenizationStrategy() {
+    const strategy = process.env.KIRI_TOKENIZATION_STRATEGY?.toLowerCase();
+    if (strategy === "legacy" || strategy === "hybrid") {
+        return strategy;
+    }
+    return "phrase-aware"; // デフォルト
+}
+/**
+ * 引用符で囲まれたフレーズを抽出
+ * 例: 'search "page-agent handler" test' → ["page-agent handler"]
+ */
+function extractQuotedPhrases(text) {
+    const phrases = [];
+    const quotePattern = /"([^"]+)"|'([^']+)'/g;
+    let match;
+    let remaining = text;
+    while ((match = quotePattern.exec(text)) !== null) {
+        const phrase = (match[1] || match[2] || "").trim().toLowerCase();
+        if (phrase.length >= 3) {
+            phrases.push(phrase);
+        }
+        remaining = remaining.replace(match[0], " ");
+    }
+    return { phrases, remaining };
+}
+/**
+ * 複合用語を抽出（ハイフンまたはアンダースコア区切り）
+ * Unicode文字に対応（日本語、中国語などの複合用語もサポート）
+ * 例: "page-agent lambda-handler" → ["page-agent", "lambda-handler"]
+ * 例: "user_profile file_embedding" → ["user_profile", "file_embedding"]
+ * 例: "app-日本語" → ["app-日本語"]
+ */
+function extractCompoundTerms(text) {
+    // Unicode対応: ハイフン(-)とアンダースコア(_)の両方をサポート
+    // snake_case (Python/Rust) と kebab-case を同等に扱う
+    // 注: \b はアンダースコアを単語文字として扱うため、アンダースコアでは機能しない
+    // そのため、明示的な境界チェックを使用
+    const compoundPattern = /(?:^|\s|[^\p{L}\p{N}_-])([\p{L}\p{N}]+(?:[-_][\p{L}\p{N}]+)+)(?=\s|[^\p{L}\p{N}_-]|$)/giu;
+    const matches = Array.from(text.matchAll(compoundPattern)).map((m) => m[1]);
+    return matches
+        .map((term) => term.toLowerCase())
+        .filter((term) => term.length >= 3 && !STOP_WORDS.has(term));
+}
+/**
+ * パスライクな用語を抽出
+ * Unicode文字に対応
+ * 例: "lambda/page-agent/handler" → ["lambda", "page-agent", "handler"]
+ */
+function extractPathSegments(text) {
+    // Unicode対応: パスセグメントでもUnicode文字をサポート
+    const pathPattern = /\b[\p{L}\p{N}_-]+(?:\/[\p{L}\p{N}_-]+)+\b/giu;
+    const matches = text.match(pathPattern) || [];
+    const segments = [];
+    for (const path of matches) {
+        const parts = path.toLowerCase().split("/");
+        for (const part of parts) {
+            if (part.length >= 3 && !STOP_WORDS.has(part) && !segments.includes(part)) {
+                segments.push(part);
+            }
+        }
+    }
+    return segments;
+}
+/**
+ * 通常の単語を抽出
+ * 共有トークン化ユーティリティを使用
+ */
+function extractRegularWords(text, strategy) {
+    const words = tokenizeText(text, strategy).filter((word) => word.length >= 3 && !STOP_WORDS.has(word));
+    return words;
+}
+/**
+ * テキストからキーワード、フレーズ、パスセグメントを抽出
+ * トークン化戦略に基づいて、ハイフン区切り用語の処理方法を変更
+ */
 function extractKeywords(text) {
-    const words = text
-        .toLowerCase()
-        .split(/[^a-z0-9_]+/iu)
-        .map((word) => word.trim())
-        .filter((word) => word.length >= 3 && !STOP_WORDS.has(word));
-    const unique = [];
-    for (const word of words) {
-        if (!unique.includes(word)) {
-            unique.push(word);
-            if (unique.length >= MAX_KEYWORDS) {
+    const strategy = getTokenizationStrategy();
+    const result = {
+        phrases: [],
+        keywords: [],
+        pathSegments: [],
+    };
+    // Phase 1: 引用符で囲まれたフレーズを抽出
+    const { phrases: quotedPhrases, remaining: afterQuotes } = extractQuotedPhrases(text);
+    result.phrases.push(...quotedPhrases);
+    // Phase 2: パスセグメントを抽出
+    const pathSegments = extractPathSegments(afterQuotes);
+    result.pathSegments.push(...pathSegments);
+    // Phase 3: 複合用語を抽出（ハイフン/アンダースコア区切り）（phrase-aware または hybrid モード）
+    if (strategy === "phrase-aware" || strategy === "hybrid") {
+        const compoundTerms = extractCompoundTerms(afterQuotes);
+        result.phrases.push(...compoundTerms);
+        // hybrid モードの場合、複合用語を分割したキーワードも追加
+        if (strategy === "hybrid") {
+            for (const term of compoundTerms) {
+                // ハイフンとアンダースコアの両方で分割
+                const parts = term
+                    .split(/[-_]/)
+                    .filter((part) => part.length >= 3 && !STOP_WORDS.has(part));
+                result.keywords.push(...parts);
+            }
+        }
+    }
+    // Phase 4: 通常の単語を抽出
+    const regularWords = extractRegularWords(afterQuotes, strategy);
+    // 重複を除去しながら、最大キーワード数まで追加
+    for (const word of regularWords) {
+        if (!result.keywords.includes(word) && !result.phrases.includes(word)) {
+            result.keywords.push(word);
+            if (result.keywords.length >= MAX_KEYWORDS) {
                 break;
             }
         }
     }
-    return unique;
+    return result;
 }
 function ensureCandidate(map, filePath) {
     let candidate = map.get(filePath);
@@ -96,6 +199,7 @@ function ensureCandidate(map, filePath) {
         candidate = {
             path: filePath,
             score: 0,
+            scoreMultiplier: 1.0, // Default: no boost or penalty
             reasons: new Set(),
             matchLine: null,
             content: null,
@@ -257,14 +361,15 @@ function splitQueryWords(query) {
     return words.length > 0 ? words : [query]; // 全て除外された場合は元のクエリを使用
 }
 /**
- * ファイルタイプに基づいてスコアをブーストする
- * プロファイルに応じて実装ファイルまたはドキュメントを優遇
+ * files_search専用のファイルタイプブースト適用（v0.7.0+: 設定可能な乗算的ペナルティ）
+ * context_bundleと同じ乗算的ペナルティロジックを使用
  * @param path - ファイルパス
- * @param baseScore - 元のスコア
- * @param profile - ブーストプロファイル ("default" | "docs" | "none")
+ * @param baseScore - 基本スコア（FTS BM25スコアまたは1.0）
+ * @param profile - ブーストプロファイル
+ * @param weights - スコアリングウェイト設定（乗算的ペナルティに使用）
  * @returns ブースト適用後のスコア
  */
-function applyFileTypeBoost(path, baseScore, profile = "default") {
+function applyFileTypeBoost(path, baseScore, profile = "default", weights) {
     // Blacklisted directories that are almost always irrelevant for code context
     const blacklistedDirs = [
         ".cursor/",
@@ -281,54 +386,91 @@ function applyFileTypeBoost(path, baseScore, profile = "default") {
     if (profile === "none") {
         return baseScore;
     }
+    // Extract file extension for type detection
+    const ext = path.includes(".") ? path.substring(path.lastIndexOf(".")) : null;
+    // ✅ UNIFIED LOGIC: Use same multiplicative penalties as context_bundle
     if (profile === "docs") {
+        // Boost documentation files
         if (path.endsWith(".md") || path.endsWith(".yaml") || path.endsWith(".yml")) {
-            return baseScore * 1.8; // Stronger boost for docs
+            return baseScore * 1.5; // 50% boost (same as context_bundle)
         }
+        // Penalty for implementation files in docs mode
         if (path.startsWith("src/") &&
             (path.endsWith(".ts") || path.endsWith(".js") || path.endsWith(".tsx"))) {
-            return baseScore * 0.5; // Stronger penalty for implementation files
+            return baseScore * 0.5; // 50% penalty
         }
         return baseScore;
     }
-    // Default profile: prioritize implementation files, heavily penalize docs
+    // Default profile: Use configurable multiplicative penalties
+    let multiplier = 1.0;
+    // Documentation files: apply docPenaltyMultiplier
     const docExtensions = [".md", ".yaml", ".yml", ".mdc", ".json"];
-    if (docExtensions.some((ext) => path.endsWith(ext))) {
-        return baseScore * 0.1; // Heavy penalty for docs
+    if (docExtensions.some((docExt) => path.endsWith(docExt))) {
+        multiplier *= weights.docPenaltyMultiplier; // 0.3 = 70% reduction (Phase 1)
+        return baseScore * multiplier;
     }
+    // Implementation file boosts: apply implBoostMultiplier with path-based scaling
     if (path.startsWith("src/app/")) {
-        return baseScore * 1.8;
+        multiplier *= weights.implBoostMultiplier * 1.4; // Extra boost for app files
     }
-    if (path.startsWith("src/components/")) {
-        return baseScore * 1.7;
+    else if (path.startsWith("src/components/")) {
+        multiplier *= weights.implBoostMultiplier * 1.3;
     }
-    if (path.startsWith("src/lib/")) {
-        return baseScore * 1.6;
+    else if (path.startsWith("src/lib/")) {
+        multiplier *= weights.implBoostMultiplier * 1.2;
     }
-    if (path.startsWith("src/") &&
-        (path.endsWith(".ts") || path.endsWith(".js") || path.endsWith(".tsx"))) {
-        return baseScore * 1.5;
+    else if (path.startsWith("src/")) {
+        if (ext === ".ts" || ext === ".tsx" || ext === ".js") {
+            multiplier *= weights.implBoostMultiplier; // Base impl boost
+        }
     }
+    // Test files: additive penalty (keep strong for files_search)
     if (path.startsWith("tests/") || path.startsWith("test/")) {
-        return baseScore * 0.2; // Also penalize tests in default mode
+        return baseScore * 0.2; // Strong penalty for tests
     }
-    return baseScore;
+    return baseScore * multiplier;
 }
 /**
- * contextBundle専用のブーストプロファイル適用
- * candidateのスコアと理由を直接変更する
- * @param candidate - スコアリング対象の候補
- * @param row - ファイル情報（path, ext）
- * @param profile - ブーストプロファイル
+ * パスベースのスコアリングを適用（加算的ブースト）
+ * goalのキーワード/フレーズがファイルパスに含まれる場合にスコアを加算
  */
-function applyBoostProfile(candidate, row, profile) {
-    if (profile === "none") {
+function applyPathBasedScoring(candidate, lowerPath, weights, extractedTerms) {
+    if (!extractedTerms || weights.pathMatch <= 0) {
         return;
     }
-    const { path, ext } = row;
-    const lowerPath = path.toLowerCase();
-    const fileName = path.split("/").pop() ?? "";
-    // Blacklisted directories that are almost always irrelevant for code context
+    // フレーズがパスに完全一致する場合（最高の重み）
+    for (const phrase of extractedTerms.phrases) {
+        if (lowerPath.includes(phrase)) {
+            candidate.score += weights.pathMatch * 1.5; // 1.5倍のブースト
+            candidate.reasons.add(`path-phrase:${phrase}`);
+            return; // 最初のマッチのみ適用
+        }
+    }
+    // パスセグメントがマッチする場合（中程度の重み）
+    const pathParts = lowerPath.split("/");
+    for (const segment of extractedTerms.pathSegments) {
+        if (pathParts.includes(segment)) {
+            candidate.score += weights.pathMatch;
+            candidate.reasons.add(`path-segment:${segment}`);
+            return; // 最初のマッチのみ適用
+        }
+    }
+    // 通常のキーワードがパスに含まれる場合（低い重み）
+    for (const keyword of extractedTerms.keywords) {
+        if (lowerPath.includes(keyword)) {
+            candidate.score += weights.pathMatch * 0.5; // 0.5倍のブースト
+            candidate.reasons.add(`path-keyword:${keyword}`);
+            return; // 最初のマッチのみ適用
+        }
+    }
+}
+/**
+ * 加算的ファイルペナルティを適用
+ * ブラックリストディレクトリ、テストファイル、lockファイル、設定ファイル、マイグレーションファイルに強いペナルティ
+ * @returns true if penalty was applied and processing should stop
+ */
+function applyAdditiveFilePenalties(candidate, path, lowerPath, fileName) {
+    // Blacklisted directories - effectively remove
     const blacklistedDirs = [
         ".cursor/",
         ".devcontainer/",
@@ -352,18 +494,18 @@ function applyBoostProfile(candidate, row, profile) {
         "temp/",
     ];
     if (blacklistedDirs.some((dir) => path.startsWith(dir))) {
-        candidate.score = -100; // Effectively remove it
+        candidate.score = -100;
         candidate.reasons.add("penalty:blacklisted-dir");
-        return;
+        return true;
     }
-    // Penalize test files explicitly (even if outside test directories)
+    // Test files - strong penalty
     const testPatterns = [".spec.ts", ".spec.js", ".test.ts", ".test.js", ".spec.tsx", ".test.tsx"];
     if (testPatterns.some((pattern) => lowerPath.endsWith(pattern))) {
-        candidate.score -= 2.0; // Strong penalty for test files
+        candidate.score -= 2.0;
         candidate.reasons.add("penalty:test-file");
-        return;
+        return true;
     }
-    // Penalize lock files and package manifests
+    // Lock files - very strong penalty
     const lockFiles = [
         "package-lock.json",
         "pnpm-lock.yaml",
@@ -374,11 +516,11 @@ function applyBoostProfile(candidate, row, profile) {
         "poetry.lock",
     ];
     if (lockFiles.some((lockFile) => fileName === lockFile)) {
-        candidate.score -= 3.0; // Very strong penalty for lock files
+        candidate.score -= 3.0;
         candidate.reasons.add("penalty:lock-file");
-        return;
+        return true;
     }
-    // Penalize configuration files
+    // Configuration files - strong penalty
     const configPatterns = [
         ".config.js",
         ".config.ts",
@@ -399,56 +541,96 @@ function applyBoostProfile(candidate, row, profile) {
         fileName === "Dockerfile" ||
         fileName === "docker-compose.yml" ||
         fileName === "docker-compose.yaml") {
-        candidate.score -= 1.5; // Strong penalty for config files
+        candidate.score -= 1.5;
         candidate.reasons.add("penalty:config-file");
-        return;
+        return true;
     }
-    // Penalize migration files (by path content)
+    // Migration files - strong penalty
     if (lowerPath.includes("migrate") || lowerPath.includes("migration")) {
-        candidate.score -= 2.0; // Strong penalty for migrations
+        candidate.score -= 2.0;
         candidate.reasons.add("penalty:migration-file");
+        return true;
+    }
+    return false; // No penalty applied, continue processing
+}
+/**
+ * ファイルタイプ別の乗算的ペナルティ/ブーストを適用（v0.7.0+）
+ * profile="docs": ドキュメントファイルをブースト
+ * profile="default": ドキュメントファイルにペナルティ、実装ファイルをブースト
+ */
+function applyFileTypeMultipliers(candidate, path, ext, profile, weights) {
+    if (profile === "none") {
         return;
     }
+    // ✅ CRITICAL SAFETY: profile="docs" mode boosts docs, skips penalties
     if (profile === "docs") {
-        // DOCS PROFILE: Boost docs, penalize code
-        if (path.endsWith(".md") || path.endsWith(".yaml") || path.endsWith(".yml")) {
-            candidate.score += 0.8;
+        const docExtensions = [".md", ".yaml", ".yml", ".mdc"];
+        if (docExtensions.some((docExt) => path.endsWith(docExt))) {
+            candidate.scoreMultiplier *= 1.5; // 50% boost for docs
             candidate.reasons.add("boost:doc-file");
         }
-        else if (path.startsWith("src/") && (ext === ".ts" || ext === ".tsx" || ext === ".js")) {
-            candidate.score -= 0.5;
-            candidate.reasons.add("penalty:impl-file");
-        }
+        // No penalty for implementation files in "docs" mode
+        return;
     }
-    else if (profile === "default") {
-        // DEFAULT PROFILE: Penalize docs heavily, boost implementation files.
-        // Penalize documentation and other non-code files
+    // DEFAULT PROFILE: Use MULTIPLICATIVE penalties for docs, MULTIPLICATIVE boosts for impl files
+    if (profile === "default") {
         const docExtensions = [".md", ".yaml", ".yml", ".mdc", ".json"];
         if (docExtensions.some((docExt) => path.endsWith(docExt))) {
-            candidate.score -= 1.0; // Strong penalty to overcome structural similarity
+            // ✅ MULTIPLICATIVE penalty (v0.7.0): 70% reduction (Phase 1 conservative)
+            candidate.scoreMultiplier *= weights.docPenaltyMultiplier;
             candidate.reasons.add("penalty:doc-file");
+            return; // Don't apply impl boosts to docs
         }
-        // Boost implementation files, with more specific paths getting higher scores
+        // ✅ MULTIPLICATIVE boost for implementation files
         if (path.startsWith("src/app/")) {
-            candidate.score += 0.8;
+            candidate.scoreMultiplier *= weights.implBoostMultiplier * 1.4; // Extra boost for app files
             candidate.reasons.add("boost:app-file");
         }
         else if (path.startsWith("src/components/")) {
-            candidate.score += 0.7;
+            candidate.scoreMultiplier *= weights.implBoostMultiplier * 1.3;
             candidate.reasons.add("boost:component-file");
         }
         else if (path.startsWith("src/lib/")) {
-            candidate.score += 0.6;
+            candidate.scoreMultiplier *= weights.implBoostMultiplier * 1.2;
             candidate.reasons.add("boost:lib-file");
         }
         else if (path.startsWith("src/")) {
             if (ext === ".ts" || ext === ".tsx" || ext === ".js") {
-                candidate.score += 0.5;
+                candidate.scoreMultiplier *= weights.implBoostMultiplier;
                 candidate.reasons.add("boost:impl-file");
             }
         }
     }
 }
+/**
+ * contextBundle専用のブーストプロファイル適用（v0.7.0+: リファクタリング版）
+ * 複雑度を削減するために3つのヘルパー関数に分割：
+ * 1. applyPathBasedScoring: パスベースの加算的スコアリング
+ * 2. applyAdditiveFilePenalties: 強力な加算的ペナルティ
+ * 3. applyFileTypeMultipliers: 乗算的ペナルティ/ブースト
+ *
+ * CRITICAL SAFETY RULES:
+ * 1. Multipliers are stored in candidate.scoreMultiplier, applied AFTER all additive scoring
+ * 2. profile="docs" skips documentation penalties (allows doc-focused queries)
+ * 3. Blacklist/test/lock/config files keep additive penalties (already very strong)
+ */
+function applyBoostProfile(candidate, row, profile, weights, extractedTerms) {
+    if (profile === "none") {
+        return;
+    }
+    const { path, ext } = row;
+    const lowerPath = path.toLowerCase();
+    const fileName = path.split("/").pop() ?? "";
+    // Step 1: パスベースのスコアリング（加算的ブースト）
+    applyPathBasedScoring(candidate, lowerPath, weights, extractedTerms);
+    // Step 2: 加算的ペナルティ（ブラックリスト、テスト、lock、設定、マイグレーション）
+    const shouldStop = applyAdditiveFilePenalties(candidate, path, lowerPath, fileName);
+    if (shouldStop) {
+        return; // ペナルティが適用された場合は処理終了
+    }
+    // Step 3: ファイルタイプ別の乗算的ペナルティ/ブースト
+    applyFileTypeMultipliers(candidate, path, ext, profile, weights);
+}
 export async function filesSearch(context, params) {
     const { db, repoId } = context;
     const { query } = params;
@@ -531,11 +713,14 @@ export async function filesSearch(context, params) {
     }
     const rows = await db.all(sql, values);
     const boostProfile = params.boost_profile ?? "default";
+    // ✅ v0.7.0+: Load configurable scoring weights for unified boosting logic
+    // Note: filesSearch doesn't have a separate profile parameter, uses default weights
+    const weights = loadScoringProfile(null);
     return rows
         .map((row) => {
         const { preview, line } = buildPreview(row.content ?? "", query);
         const baseScore = row.score ?? 1.0; // FTS時はBM25スコア、ILIKE時は1.0
-        const boostedScore = applyFileTypeBoost(row.path, baseScore, boostProfile);
+        const boostedScore = applyFileTypeBoost(row.path, baseScore, boostProfile, weights);
         return {
             path: row.path,
             preview,
@@ -649,18 +834,84 @@ export async function contextBundle(context, params) {
     }
     const semanticSeed = keywordSources.join(" ");
     const queryEmbedding = generateEmbedding(semanticSeed)?.values ?? null;
-    let keywords = extractKeywords(semanticSeed);
-    if (keywords.length === 0 && artifacts.editing_path) {
+    const extractedTerms = extractKeywords(semanticSeed);
+    // フォールバック: editing_pathからキーワードを抽出
+    if (extractedTerms.phrases.length === 0 &&
+        extractedTerms.keywords.length === 0 &&
+        artifacts.editing_path) {
         const pathSegments = artifacts.editing_path
             .split(/[/_.-]/)
             .map((segment) => segment.toLowerCase())
             .filter((segment) => segment.length >= 3 && !STOP_WORDS.has(segment));
-        keywords = pathSegments.slice(0, MAX_KEYWORDS);
+        extractedTerms.pathSegments.push(...pathSegments.slice(0, MAX_KEYWORDS));
     }
     const candidates = new Map();
     const stringMatchSeeds = new Set();
     const fileCache = new Map();
-    for (const keyword of keywords) {
+    // フレーズマッチング（高い重み: textMatch × 2）- 統合クエリでパフォーマンス改善
+    if (extractedTerms.phrases.length > 0) {
+        const phrasePlaceholders = extractedTerms.phrases
+            .map(() => "b.content ILIKE '%' || ? || '%'")
+            .join(" OR ");
+        const rows = await db.all(`
+        SELECT f.path, f.lang, f.ext, f.is_binary, b.content, fe.vector_json, fe.dims AS vector_dims
+        FROM file f
+        JOIN blob b ON b.hash = f.blob_hash
+        LEFT JOIN file_embedding fe
+          ON fe.repo_id = f.repo_id
+         AND fe.path = f.path
+        WHERE f.repo_id = ?
+          AND f.is_binary = FALSE
+          AND (${phrasePlaceholders})
+        ORDER BY f.path
+        LIMIT ?
+      `, [repoId, ...extractedTerms.phrases, MAX_MATCHES_PER_KEYWORD * extractedTerms.phrases.length]);
+        const boostProfile = params.boost_profile ?? "default";
+        for (const row of rows) {
+            if (row.content === null) {
+                continue;
+            }
+            // どのフレーズにマッチしたかをチェック
+            const lowerContent = row.content.toLowerCase();
+            const matchedPhrases = extractedTerms.phrases.filter((phrase) => lowerContent.includes(phrase));
+            if (matchedPhrases.length === 0) {
+                continue; // Should not happen, but defensive check
+            }
+            const candidate = ensureCandidate(candidates, row.path);
+            // 各マッチしたフレーズに対してスコアリング
+            for (const phrase of matchedPhrases) {
+                // フレーズマッチは通常の2倍のスコア
+                candidate.score += weights.textMatch * 2.0;
+                candidate.reasons.add(`phrase:${phrase}`);
+            }
+            // Apply boost profile once per file
+            applyBoostProfile(candidate, row, boostProfile, weights, extractedTerms);
+            // Use first matched phrase for preview (guaranteed to exist due to length check above)
+            const { line } = buildPreview(row.content, matchedPhrases[0]);
+            candidate.matchLine =
+                candidate.matchLine === null ? line : Math.min(candidate.matchLine, line);
+            candidate.content ??= row.content;
+            candidate.lang ??= row.lang;
+            candidate.ext ??= row.ext;
+            candidate.totalLines ??= row.content.length === 0 ? 0 : row.content.split(/\r?\n/).length;
+            candidate.embedding ??= parseEmbedding(row.vector_json ?? null, row.vector_dims ?? null);
+            stringMatchSeeds.add(row.path);
+            if (!fileCache.has(row.path)) {
+                fileCache.set(row.path, {
+                    content: row.content,
+                    lang: row.lang,
+                    ext: row.ext,
+                    totalLines: candidate.totalLines ?? 0,
+                    embedding: candidate.embedding,
+                });
+            }
+        }
+    }
+    // キーワードマッチング（通常の重み）- 統合クエリでパフォーマンス改善
+    if (extractedTerms.keywords.length > 0) {
+        const keywordPlaceholders = extractedTerms.keywords
+            .map(() => "b.content ILIKE '%' || ? || '%'")
+            .join(" OR ");
         const rows = await db.all(`
         SELECT f.path, f.lang, f.ext, f.is_binary, b.content, fe.vector_json, fe.dims AS vector_dims
         FROM file f
@@ -670,21 +921,31 @@ export async function contextBundle(context, params) {
          AND fe.path = f.path
         WHERE f.repo_id = ?
           AND f.is_binary = FALSE
-          AND b.content ILIKE '%' || ? || '%'
+          AND (${keywordPlaceholders})
         ORDER BY f.path
         LIMIT ?
-      `, [repoId, keyword, MAX_MATCHES_PER_KEYWORD]);
+      `, [repoId, ...extractedTerms.keywords, MAX_MATCHES_PER_KEYWORD * extractedTerms.keywords.length]);
+        const boostProfile = params.boost_profile ?? "default";
         for (const row of rows) {
             if (row.content === null) {
                 continue;
             }
+            // どのキーワードにマッチしたかをチェック
+            const lowerContent = row.content.toLowerCase();
+            const matchedKeywords = extractedTerms.keywords.filter((keyword) => lowerContent.includes(keyword));
+            if (matchedKeywords.length === 0) {
+                continue; // Should not happen, but defensive check
+            }
             const candidate = ensureCandidate(candidates, row.path);
-            candidate.score += weights.textMatch;
-            candidate.reasons.add(`text:${keyword}`);
-            // Apply boost profile to prioritize/penalize files based on type and location
-            const boostProfile = params.boost_profile ?? "default";
-            applyBoostProfile(candidate, row, boostProfile);
-            const { line } = buildPreview(row.content, keyword);
+            // 各マッチしたキーワードに対してスコアリング
+            for (const keyword of matchedKeywords) {
+                candidate.score += weights.textMatch;
+                candidate.reasons.add(`text:${keyword}`);
+            }
+            // Apply boost profile once per file
+            applyBoostProfile(candidate, row, boostProfile, weights, extractedTerms);
+            // Use first matched keyword for preview (guaranteed to exist due to length check above)
+            const { line } = buildPreview(row.content, matchedKeywords[0]);
             candidate.matchLine =
                 candidate.matchLine === null ? line : Math.min(candidate.matchLine, line);
             candidate.content ??= row.content;
@@ -806,6 +1067,13 @@ export async function contextBundle(context, params) {
         return { context: [], tokens_estimate: 0 };
     }
     applyStructuralScores(materializedCandidates, queryEmbedding, weights.structural);
+    // ✅ CRITICAL SAFETY: Apply multipliers AFTER all additive scoring (v0.7.0)
+    // Only apply to positive scores to prevent negative score inversion
+    for (const candidate of materializedCandidates) {
+        if (candidate.scoreMultiplier !== 1.0 && candidate.score > 0) {
+            candidate.score *= candidate.scoreMultiplier;
+        }
+    }
     const sortedCandidates = materializedCandidates
         .filter((candidate) => candidate.score > 0) // Filter out candidates with negative or zero scores
         .sort((a, b) => {