orion-super-agent-dev 0.1.32 → 0.1.34

package/out/indexProcessWorker.cjs

@@ -2792,6 +2792,8 @@ function normalizeEdge(edge) {
 var EMPTY_FILE_SET = /* @__PURE__ */ new Set();
 var GRAPH_EXPANSION_MAX_SEEDS = 5;
 var GRAPH_EXPANSION_PER_SEED = 8;
+var JUDGE_DEFINES_SHOWN = 6;
+var JUDGE_TESTS_SHOWN = 3;
 var GRAPH_DEPENDENT_VERB = {
   calls: "calls into",
   imports: "imports",
@@ -3391,7 +3393,11 @@ var WorkspaceIndexStore = class {
     const missRank = options.attention?.length ?? 0;
     return [...candidates].map((p) => [p, sets.filter((s) => s.has(p)).length]).sort((a, b) => b[1] - a[1] || (attentionRank.get(a[0]) ?? missRank) - (attentionRank.get(b[0]) ?? missRank) || a[0].localeCompare(b[0])).slice(0, options.topK ?? 30);
   }
-  async searchCodebase(input) {
+  /** The ranked search before rendering. `pool` widens the fusion past `max_results`
+   *  (the judge's candidate list) — every channel then contributes up to the pool and
+   *  the fused order runs to it; the cards, and the related context behind them, stop
+   *  at `max_results` as they always did. A string is the not-ready answer, as-is. */
+  async rankCodebase(input, pool = 0) {
     const query = String(input.query ?? "").trim();
     if (!query) throw new Error("`query` is required");
     const scope = String(input.scope ?? "").trim() || void 0;
@@ -3409,14 +3415,37 @@ var WorkspaceIndexStore = class {
       ].join("\n");
     }
     const attention = Array.isArray(input.attention) ? input.attention.filter((p) => typeof p === "string") : void 0;
-    const perSource = Math.max(maxResults, 12);
+    const fusionSize = Math.max(maxResults, pool);
+    const perSource = Math.max(fusionSize, 12);
     const termSets = await this.termFileSets(queryTerms(query));
     const symbols = this.symbolHitsForQuery(query, perSource, attention, scope);
     const files = this.fileHitsForQuery(query, perSource, attention, scope, termSets);
     const content = await this.contentHitsForQuery(query, perSource, attention, scope, termSets);
     const seeds = this.graphExpansionSeeds(symbols, files);
     const graph = seeds.length > 0 ? this.graphHitsForQuery(seeds, perSource, scope, queryTerms(query), termSets) : [];
-    const merged = fuseHits([symbols, files, content, graph], maxResults);
+    const merged = fuseHits([symbols, files, content, graph], fusionSize);
+    const topPaths = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const hit of merged) {
+      const p = String(hit.path ?? "");
+      if (!p || seen.has(p)) continue;
+      seen.add(p);
+      const reasons = Array.isArray(hit.result_types) ? [...hit.result_types.map(String)] : [String(hit.result_type ?? "match")];
+      if (Array.isArray(hit.reasons)) reasons.push(...hit.reasons.map(String));
+      topPaths.push([p, reasons]);
+    }
+    const testsLimit = detailLimit(detail, 3, 6, 12);
+    const relatedLimit = Math.max(detailLimit(detail, 2, 4, 7), testsLimit);
+    const relatedByPath = /* @__PURE__ */ new Map();
+    for (const [p] of topPaths.slice(0, maxResults)) {
+      relatedByPath.set(p, await this.relatedContextForPath(p, relatedLimit));
+    }
+    return { query, scope, detail, intent, maxResults, attention, symbols, content, topPaths, relatedByPath };
+  }
+  /** The normal level's result for the model, from a ranked search. */
+  renderSearch(r) {
+    const { query, scope, detail, intent, maxResults, symbols, content, relatedByPath } = r;
+    const cardPaths = r.topPaths.slice(0, maxResults);
     const lines = [
       "Index Status",
       `- ${this.indexSummary()}`,
@@ -3430,31 +3459,16 @@ var WorkspaceIndexStore = class {
       "",
       "Top Files"
     ];
-    if (merged.length === 0) {
+    if (cardPaths.length === 0) {
       lines.push("- no indexed matches");
       lines.push("");
       lines.push("Suggested Next Moves");
       lines.push("- use grep for exact strings or when the index has not learned this term");
       return lines.join("\n");
     }
-    const topPaths = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const hit of merged) {
-      const p = String(hit.path ?? "");
-      if (!p || seen.has(p)) continue;
-      seen.add(p);
-      const reasons = Array.isArray(hit.result_types) ? [...hit.result_types.map(String)] : [String(hit.result_type ?? "match")];
-      if (Array.isArray(hit.reasons)) reasons.push(...hit.reasons.map(String));
-      topPaths.push([p, reasons]);
-    }
     const testsLimit = detailLimit(detail, 3, 6, 12);
-    const relatedLimit = Math.max(detailLimit(detail, 2, 4, 7), testsLimit);
-    const relatedByPath = /* @__PURE__ */ new Map();
-    for (const [p] of topPaths) {
-      relatedByPath.set(p, await this.relatedContextForPath(p, relatedLimit));
-    }
     let cardRank = 0;
-    for (const [p, cardReasons] of topPaths.slice(0, maxResults)) {
+    for (const [p, cardReasons] of cardPaths) {
       cardRank += 1;
       lines.push(...this.renderFileCard(p, cardRank, cardReasons, detail, relatedByPath.get(p)));
     }
@@ -3481,14 +3495,14 @@ var WorkspaceIndexStore = class {
       }
     }
     const relatedTestLists = [];
-    for (const [p] of topPaths) {
+    for (const [p] of cardPaths) {
       relatedTestLists.push((relatedByPath.get(p)?.tests ?? []).slice(0, testsLimit));
     }
     const relatedTests = dedupe(relatedTestLists.flat(), (p) => p, testsLimit);
     if (relatedTests.length > 0) {
       lines.push("", "Likely Tests", ...relatedTests.map((p) => `- ${p}`));
     }
-    const hasGraphHits = topPaths.some(([, reasons]) => reasons.some((r) => r === "graph" || r.startsWith("graph:")));
+    const hasGraphHits = cardPaths.some(([, reasons]) => reasons.some((r2) => r2 === "graph" || r2.startsWith("graph:")));
     lines.push(
       "",
       "Use This Result",
@@ -3509,6 +3523,51 @@ var WorkspaceIndexStore = class {
     );
     return lines.join("\n");
   }
+  async searchCodebase(input) {
+    const ranked = await this.rankCodebase(input);
+    return typeof ranked === "string" ? ranked : this.renderSearch(ranked);
+  }
+  /** The judge's candidate list: the same search over the stamp's wider pool, its
+   *  fused order as metadata beside the ordinary output. Each candidate names its
+   *  best-matching lines (the ranker's top chunk for the file, else its first chunk)
+   *  as a RANGE — the executor reads the leading ones' text, since the store never
+   *  touches the disk. Null while the index is not ready (the caller runs the plain
+   *  search, whose not-ready answer says so). */
+  async searchCodebaseJudged(input, stamp) {
+    const ranked = await this.rankCodebase(input, Math.max(1, Math.floor(stamp.pool)));
+    if (typeof ranked === "string") return null;
+    const attention = new Set(ranked.attention ?? []);
+    const topChunkByPath = /* @__PURE__ */ new Map();
+    for (const hit of ranked.content) {
+      if (hit.result_type !== "chunk") continue;
+      const p = String(hit.path ?? "");
+      if (!p || topChunkByPath.has(p)) continue;
+      topChunkByPath.set(p, { start_line: Number(hit.line), end_line: Number(hit.end_line) });
+    }
+    const candidates = ranked.topPaths.map(([p, reasons], i2) => {
+      const meta = this.fileMeta.get(p);
+      const flags2 = [];
+      if (meta?.is_test) flags2.push("test");
+      if (meta?.is_generated) flags2.push("generated");
+      if (attention.has(p)) flags2.push("open");
+      const syms = this.listSymbols(p);
+      const defines = syms.slice(0, JUDGE_DEFINES_SHOWN).map((s) => `${s.name}@${s.line}`);
+      if (syms.length > JUDGE_DEFINES_SHOWN) defines.push(`(+${syms.length - JUDGE_DEFINES_SHOWN} more)`);
+      const first = this.chunkIndex.bestChunksForPath(p, 1)[0];
+      const range = topChunkByPath.get(p) ?? (first ? { start_line: first.startLine, end_line: first.endLine } : null);
+      return {
+        rank: i2 + 1,
+        path: p,
+        reasons: dedupe(reasons, (r) => r, 6),
+        summary: this.fileSummaryFor(p),
+        defines,
+        flags: flags2,
+        tests: (ranked.relatedByPath.get(p)?.tests ?? []).slice(0, JUDGE_TESTS_SHOWN),
+        snippet: range && range.start_line > 0 ? { ...range, text: "" } : null
+      };
+    });
+    return { output: this.renderSearch(ranked), index_summary: this.indexSummary(), candidates };
+  }
   async traceCodebase(input) {
     const target = String(input.target ?? "").trim();
     if (!target) throw new Error("`target` is required");
@@ -8330,6 +8389,9 @@ var VectorStore = class {
 };
 
 // ../packages/orion-client-core/src/enhancedRetrieval.ts
+function vectorLayerModel(provider, model) {
+  return provider ? `${provider}/${model}` : model;
+}
 var ENHANCED_TEST_DIRS = /* @__PURE__ */ new Set(["test", "tests", "testing"]);
 var ENHANCED_CHUNK_SOURCE_CHARS = 1e4;
 var ENHANCED_EMBED_BATCH_SIZE = 16;
@@ -8475,7 +8537,13 @@ async function runEnhancedRetrieve(request, deps) {
     files_truncated: 0,
     elapsed_ms: 0
   };
-  const store2 = new VectorStore({ root: deps.root, model, baseDir: deps.baseDir, fsOps: deps.fsOps, log });
+  const store2 = new VectorStore({
+    root: deps.root,
+    model: vectorLayerModel(provider, model),
+    baseDir: deps.baseDir,
+    fsOps: deps.fsOps,
+    log
+  });
   await store2.load();
   try {
     const rowByHash = /* @__PURE__ */ new Map();
@@ -8863,6 +8931,7 @@ var READ_METHODS = /* @__PURE__ */ new Set([
   "readRangeSuggestions",
   "readContextHeader",
   "searchCodebase",
+  "searchCodebaseJudged",
   "traceCodebase",
   "enhancedRetrieve",
   "dependencyAdvisory"
@@ -8943,6 +9012,11 @@ async function handle3(method, params) {
       );
     case "searchCodebase":
       return store.searchCodebase(params.input ?? {});
+    case "searchCodebaseJudged":
+      return store.searchCodebaseJudged(
+        params.input ?? {},
+        params.stamp
+      );
     case "traceCodebase":
       return store.traceCodebase(params.input ?? {});
     case "enhancedRetrieve":