kontext-engine 0.1.0 → 0.1.1

package/dist/cli/index.js

@@ -1687,6 +1687,57 @@ 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 queryLower = query.toLowerCase();
+  const allPaths = db.getAllFilePaths();
+  const scoredPaths = [];
+  for (const filePath of allPaths) {
+    const score = scorePathMatch(filePath, queryLower);
+    if (score > 0) {
+      scoredPaths.push({ filePath, score });
+    }
+  }
+  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 +1769,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 +1887,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 +1903,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 +1969,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 +1986,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),