kontext-engine 0.1.1 → 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);
@@ -1691,13 +1696,17 @@ var SCORE_DIR_EXACT = 1;
 var SCORE_FILENAME = 0.9;
 var SCORE_PARTIAL = 0.7;
 function pathKeywordSearch(db, query, limit) {
-  const queryLower = query.toLowerCase();
+  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) {
-    const score = scorePathMatch(filePath, queryLower);
-    if (score > 0) {
-      scoredPaths.push({ filePath, score });
+    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 [];
@@ -2146,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",
@@ -2154,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}`,
@@ -2344,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": {
@@ -2352,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 [];
   }
@@ -2368,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 {
@@ -2401,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);
       }
@@ -2468,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 {