kontext-engine 0.1.0 → 0.1.2

package/dist/cli/index.js

@@ -1568,12 +1568,17 @@ async function vectorSearch(db, embedder, query, limit, filters) {
 }
 
 // src/search/fts.ts
+function sanitizeFtsQuery(query) {
+  return query.replace(/[?()":^~{}!+\-\\]/g, " ").replace(/(?<!\w)\*/g, " ").replace(/\s+/g, " ").trim();
+}
 function bm25ToScore(rank) {
   return 1 / (1 + Math.abs(rank));
 }
 function ftsSearch(db, query, limit, filters) {
+  const safeQuery = sanitizeFtsQuery(query);
+  if (safeQuery.length === 0) return [];
   const fetchLimit = filters?.language ? limit * 3 : limit;
-  const ftsResults = db.searchFTS(query, fetchLimit);
+  const ftsResults = db.searchFTS(safeQuery, fetchLimit);
   if (ftsResults.length === 0) return [];
   const chunkIds = ftsResults.map((r) => r.chunkId);
   const chunks = db.getChunksByIds(chunkIds);
@@ -1687,6 +1692,61 @@ function pathSearch(db, pattern, limit) {
   }
   return results;
 }
+var SCORE_DIR_EXACT = 1;
+var SCORE_FILENAME = 0.9;
+var SCORE_PARTIAL = 0.7;
+function pathKeywordSearch(db, query, limit) {
+  const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length >= 2);
+  if (terms.length === 0) return [];
+  const allPaths = db.getAllFilePaths();
+  const scoredPaths = [];
+  for (const filePath of allPaths) {
+    let bestScore = 0;
+    for (const term of terms) {
+      bestScore = Math.max(bestScore, scorePathMatch(filePath, term));
+    }
+    if (bestScore > 0) {
+      scoredPaths.push({ filePath, score: bestScore });
+    }
+  }
+  if (scoredPaths.length === 0) return [];
+  scoredPaths.sort((a, b) => b.score - a.score);
+  const results = [];
+  for (const { filePath, score } of scoredPaths) {
+    if (results.length >= limit) break;
+    const file = db.getFile(filePath);
+    if (!file) continue;
+    const chunks = db.getChunksByFile(file.id);
+    for (const chunk of chunks) {
+      if (results.length >= limit) break;
+      results.push({
+        chunkId: chunk.id,
+        filePath: file.path,
+        lineStart: chunk.lineStart,
+        lineEnd: chunk.lineEnd,
+        name: chunk.name,
+        type: chunk.type,
+        text: chunk.text,
+        score,
+        language: file.language
+      });
+    }
+  }
+  return results;
+}
+function scorePathMatch(filePath, queryLower) {
+  const pathLower = filePath.toLowerCase();
+  const segments = pathLower.split("/");
+  const dirSegments = segments.slice(0, -1);
+  for (const seg of dirSegments) {
+    if (seg === queryLower) return SCORE_DIR_EXACT;
+  }
+  const fileName = segments[segments.length - 1];
+  const fileNameNoExt = fileName.replace(/\.[^.]+$/, "");
+  if (fileNameNoExt === queryLower) return SCORE_FILENAME;
+  if (pathLower.includes(queryLower)) return SCORE_PARTIAL;
+  return 0;
+}
 
 // src/search/fusion.ts
 var K = 60;
@@ -1718,6 +1778,73 @@ function fusionMerge(strategyResults, limit) {
   }
   return results;
 }
+var PATH_BOOST_DIR_EXACT = 1.5;
+var PATH_BOOST_FILENAME = 1.4;
+var PATH_BOOST_PARTIAL = 1.2;
+var IMPORT_PENALTY = 0.5;
+function fusionMergeWithPathBoost(strategyResults, limit, pathBoostTerms) {
+  const fused = fusionMerge(strategyResults, limit * 3);
+  if (fused.length === 0) return [];
+  const boosted = applyPathBoost(fused, pathBoostTerms);
+  const adjusted = applyImportDeprioritization(boosted);
+  adjusted.sort((a, b) => b.score - a.score);
+  const sliced = adjusted.slice(0, limit);
+  return renormalize(sliced);
+}
+function applyPathBoost(results, terms) {
+  if (terms.length === 0) return results;
+  return results.map((r) => {
+    const boost = getPathBoostFactor(r.filePath, terms);
+    return { ...r, score: r.score * boost };
+  });
+}
+function getPathBoostFactor(filePath, terms) {
+  let maxBoost = 1;
+  const pathLower = filePath.toLowerCase();
+  const segments = pathLower.split("/");
+  const dirSegments = segments.slice(0, -1);
+  const fileName = segments[segments.length - 1];
+  const fileNameNoExt = fileName.replace(/\.[^.]+$/, "");
+  for (const term of terms) {
+    const termLower = term.toLowerCase();
+    for (const seg of dirSegments) {
+      if (seg === termLower) {
+        maxBoost = Math.max(maxBoost, PATH_BOOST_DIR_EXACT);
+      }
+    }
+    if (fileNameNoExt === termLower) {
+      maxBoost = Math.max(maxBoost, PATH_BOOST_FILENAME);
+    }
+    if (maxBoost < PATH_BOOST_PARTIAL && pathLower.includes(termLower)) {
+      maxBoost = Math.max(maxBoost, PATH_BOOST_PARTIAL);
+    }
+  }
+  return maxBoost;
+}
+function applyImportDeprioritization(results) {
+  const hasNonImport = results.some((r) => r.type !== "import");
+  if (!hasNonImport) return results;
+  const maxNonImportScore = Math.max(
+    ...results.filter((r) => r.type !== "import").map((r) => r.score),
+    0
+  );
+  if (maxNonImportScore === 0) return results;
+  return results.map((r) => {
+    if (r.type === "import") {
+      return { ...r, score: r.score * IMPORT_PENALTY };
+    }
+    return r;
+  });
+}
+function renormalize(results) {
+  if (results.length === 0) return results;
+  const maxScore = Math.max(...results.map((r) => r.score));
+  if (maxScore === 0) return results;
+  return results.map((r) => ({
+    ...r,
+    score: r.score / maxScore
+  }));
+}
 
 // src/cli/commands/query.ts
 var CTX_DIR2 = ".ctx";
@@ -1769,6 +1896,9 @@ function extractSymbolNames(query) {
 function isPathLike(query) {
   return query.includes("/") || query.includes("*") || query.includes(".");
 }
+function extractPathBoostTerms(query) {
+  return query.split(/\s+/).map((t) => t.trim()).filter((t) => t.length >= 2);
+}
 async function runQuery(projectPath, query, options) {
   const absoluteRoot = path5.resolve(projectPath);
   const dbPath = path5.join(absoluteRoot, CTX_DIR2, DB_FILENAME2);
@@ -1782,7 +1912,8 @@ async function runQuery(projectPath, query, options) {
   const db = createDatabase(dbPath);
   try {
     const strategyResults = await runStrategies(db, query, options);
-    const fused = fusionMerge(strategyResults, options.limit);
+    const pathBoostTerms = extractPathBoostTerms(query);
+    const fused = fusionMergeWithPathBoost(strategyResults, options.limit, pathBoostTerms);
     const outputResults = fused.map(toOutputResult);
     const searchTimeMs = Math.round(performance.now() - start);
     const text = options.format === "text" ? formatTextOutput(query, outputResults) : void 0;
@@ -1847,8 +1978,8 @@ async function executeStrategy(db, strategy, query, limit, filters) {
       });
     }
     case "path": {
-      if (!isPathLike(query)) return [];
-      return pathSearch(db, query, limit);
+      if (isPathLike(query)) return pathSearch(db, query, limit);
+      return pathKeywordSearch(db, query, limit);
     }
     case "dependency":
       return [];
@@ -1864,12 +1995,12 @@ function registerQueryCommand(program2) {
   program2.command("query <query>").description("Multi-strategy code search").option("-l, --limit <n>", "Max results", "10").option(
     "-s, --strategy <list>",
     "Comma-separated strategies: vector,fts,ast,path",
-    "fts,ast"
+    "fts,ast,path"
   ).option("--language <lang>", "Filter by language").option("-f, --format <fmt>", "Output format: json|text", "json").option("--no-vectors", "Skip vector search").action(async (query, opts) => {
     const projectPath = process.cwd();
     const verbose = program2.opts()["verbose"] === true;
     const logger = createLogger({ level: verbose ? LogLevel.DEBUG : LogLevel.INFO });
-    const strategies = (opts["strategy"] ?? "fts,ast").split(",").map((s) => s.trim());
+    const strategies = (opts["strategy"] ?? "fts,ast,path").split(",").map((s) => s.trim());
     try {
       const output = await runQuery(projectPath, query, {
         limit: parseInt(opts["limit"] ?? "10", 10),
@@ -2024,6 +2155,86 @@ function createAnthropicProvider(apiKey) {
     }
   };
 }
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "how",
+  "does",
+  "what",
+  "where",
+  "when",
+  "why",
+  "which",
+  "who",
+  "whom",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "do",
+  "did",
+  "doing",
+  "done",
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "not",
+  "no",
+  "nor",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "about",
+  "it",
+  "its",
+  "this",
+  "that",
+  "these",
+  "those",
+  "can",
+  "could",
+  "should",
+  "would",
+  "will",
+  "shall",
+  "may",
+  "might",
+  "has",
+  "have",
+  "had",
+  "having",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "she",
+  "they",
+  "find",
+  "show",
+  "get",
+  "tell"
+]);
+function extractSearchTerms(query) {
+  const words = query.replace(/[^a-zA-Z0-9_\s]/g, " ").split(/\s+/).filter((w) => w.length >= 2 && !STOP_WORDS.has(w.toLowerCase()));
+  if (words.length === 0) {
+    const allWords = query.replace(/[^a-zA-Z0-9_\s]/g, " ").split(/\s+/).filter((w) => w.length >= 2);
+    return allWords.sort((a, b) => b.length - a.length)[0] ?? query;
+  }
+  return words.join(" ");
+}
 var VALID_STRATEGIES = /* @__PURE__ */ new Set([
   "vector",
   "fts",
@@ -2032,9 +2243,11 @@ var VALID_STRATEGIES = /* @__PURE__ */ new Set([
   "dependency"
 ]);
 function buildFallbackPlan(query) {
+  const keywords = extractSearchTerms(query);
   const strategies = [
-    { strategy: "fts", query, weight: 0.8, reason: "Full-text keyword search" },
-    { strategy: "ast", query, weight: 0.9, reason: "Structural symbol search" }
+    { strategy: "fts", query: keywords, weight: 0.8, reason: "Full-text keyword search" },
+    { strategy: "ast", query: keywords, weight: 0.9, reason: "Structural symbol search" },
+    { strategy: "path", query: keywords, weight: 0.7, reason: "Path keyword search" }
   ];
   return {
     interpretation: `Searching for: ${query}`,
@@ -2222,6 +2435,13 @@ function createSearchExecutor(db) {
     return fusionMerge(strategyResults, limit);
   };
 }
+function extractSymbolNames2(query) {
+  const matches = query.match(/[A-Z]?[a-z]+(?:[A-Z][a-z]+)*|[a-z]+(?:_[a-z]+)+|[A-Z][a-zA-Z]+/g);
+  return matches ?? [];
+}
+function isPathLike2(query) {
+  return query.includes("/") || query.includes("*") || query.includes(".");
+}
 async function executeStrategy2(db, plan, limit) {
   switch (plan.strategy) {
     case "vector": {
@@ -2230,10 +2450,25 @@ async function executeStrategy2(db, plan, limit) {
     }
     case "fts":
       return ftsSearch(db, plan.query, limit);
-    case "ast":
-      return astSearch(db, { name: plan.query }, limit);
-    case "path":
-      return pathSearch(db, plan.query, limit);
+    case "ast": {
+      const symbols = extractSymbolNames2(plan.query);
+      if (symbols.length === 0) return [];
+      const allResults = [];
+      for (const name of symbols) {
+        const results = astSearch(db, { name }, limit);
+        allResults.push(...results);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      return allResults.filter((r) => {
+        if (seen.has(r.chunkId)) return false;
+        seen.add(r.chunkId);
+        return true;
+      });
+    }
+    case "path": {
+      if (isPathLike2(plan.query)) return pathSearch(db, plan.query, limit);
+      return pathKeywordSearch(db, plan.query, limit);
+    }
     case "dependency":
       return [];
   }
@@ -2246,9 +2481,11 @@ async function loadEmbedder2() {
 }
 async function fallbackSearch(db, query, limit) {
   const executor = createSearchExecutor(db);
+  const keywords = extractSearchTerms(query);
   const fallbackStrategies = [
-    { strategy: "fts", query, weight: 0.8, reason: "fallback keyword search" },
-    { strategy: "ast", query, weight: 0.9, reason: "fallback structural search" }
+    { strategy: "fts", query: keywords, weight: 0.8, reason: "fallback keyword search" },
+    { strategy: "ast", query: keywords, weight: 0.9, reason: "fallback structural search" },
+    { strategy: "path", query: keywords, weight: 0.7, reason: "fallback path search" }
   ];
   const results = await executor(fallbackStrategies, limit);
   return {
@@ -2279,6 +2516,7 @@ async function runAsk(projectPath, query, options) {
     const provider = options.provider ?? null;
     if (!provider) {
       const output = await fallbackSearch(db, query, options.limit);
+      output.warning = FALLBACK_NOTICE;
       if (options.format === "text") {
         output.text = formatTextOutput2(output);
       }
@@ -2346,6 +2584,9 @@ function registerAskCommand(program2) {
         provider: provider ?? void 0,
         noExplain: opts["explain"] === false
       });
+      if (output.warning) {
+        console.error(`\u26A0 ${output.warning}`);
+      }
       if (output.text) {
         console.log(output.text);
       } else {