opencode-codebase-index 0.15.0 → 0.16.0

package/dist/pi-extension.cjs

@@ -8902,10 +8902,19 @@ var Indexer = class {
     });
     const embeddingStartTime = import_perf_hooks.performance.now();
     const embeddingQuery = stripFilePathHint(query);
-    const embedding = await this.getQueryEmbedding(embeddingQuery, provider);
+    let embedding;
+    try {
+      embedding = await this.getQueryEmbedding(embeddingQuery, provider);
+    } catch (error) {
+      this.logger.warn("Query embedding failed; falling back to keyword-only search", {
+        query,
+        error: getErrorMessage2(error),
+        action: "Check the embedding provider configuration and retry search after restoring provider health."
+      });
+    }
     const embeddingMs = import_perf_hooks.performance.now() - embeddingStartTime;
     const vectorStartTime = import_perf_hooks.performance.now();
-    const semanticResults = store.search(embedding, maxResults * 4);
+    const semanticResults = embedding ? store.search(embedding, maxResults * 4) : [];
     const vectorMs = import_perf_hooks.performance.now() - vectorStartTime;
     const keywordStartTime = import_perf_hooks.performance.now();
     const keywordResults = await this.keywordSearch(query, maxResults * 4, store, invertedIndex);
@@ -8940,12 +8949,13 @@ var Indexer = class {
       });
     }
     const fusionStartTime = import_perf_hooks.performance.now();
+    const rankingHybridWeight = embedding === void 0 && fusionStrategy === "weighted" ? 1 : effectiveHybridWeight;
     const combined = rankHybridResults(query, semanticCandidates, keywordCandidates, {
       fusionStrategy,
       rrfK,
       rerankTopN,
       limit: maxResults,
-      hybridWeight: effectiveHybridWeight,
+      hybridWeight: rankingHybridWeight,
       prioritizeSourcePaths: sourceIntent
     });
     const rerankedCombined = await this.rerankCandidatesWithApi(query, combined, {
@@ -10065,6 +10075,17 @@ function calculatePercentage(progress) {
   if (progress.phase === "storing") return 95;
   return 0;
 }
+function formatCodebasePeek(results) {
+  if (results.length === 0) {
+    return "No matching code found. Try a different query or run index_codebase first.";
+  }
+  const formatted = results.map((r, idx) => {
+    const location = `${r.filePath}:${r.startLine}-${r.endLine}`;
+    const name = r.name ? `"${r.name}"` : "(anonymous)";
+    return `[${idx + 1}] ${r.chunkType} ${name} at ${location} (score: ${r.score.toFixed(2)})${formatBlame(r)}`;
+  });
+  return formatted.join("\n");
+}
 function formatHealthCheck(result) {
   if (result.resetCorruptedIndex) {
     return result.warning ?? "Detected a corrupted local index and reset it. Run index_codebase to rebuild search data.";
@@ -10651,10 +10672,67 @@ function projectRoot2(ctx) {
   return ctx?.cwd ?? process.cwd();
 }
 function codebaseIndexPiExtension(pi) {
+  pi.registerTool({
+    name: "codebase_context",
+    label: "Codebase Context",
+    description: "PREFERRED FIRST TOOL for any repository question. Check index_status when freshness is unknown, then use this tool for low-token location discovery and dependency flow.",
+    parameters: import_typebox2.Type.Object({
+      query: import_typebox2.Type.String({ description: "Natural language description of what code you're trying to locate" }),
+      from: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Source symbol when asking for a dependency path." })),
+      to: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Target symbol when asking for a dependency path." })),
+      symbol: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Exact symbol name for an authoritative definition lookup." })),
+      limit: import_typebox2.Type.Optional(import_typebox2.Type.Number({ description: "Maximum results (default: 10)" })),
+      maxDepth: import_typebox2.Type.Optional(import_typebox2.Type.Number({ description: "Maximum call-graph traversal depth for from/to paths" })),
+      fileType: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Filter by file extension, e.g., ts, py, rs" })),
+      directory: import_typebox2.Type.Optional(import_typebox2.Type.String({ description: "Filter by directory path" }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const root = projectRoot2(ctx);
+      if (params.from && params.to) {
+        const path17 = await getCallGraphPath(root, HOST2, params.from, params.to, params.maxDepth);
+        if (path17.length > 0) {
+          return text2(formatCallGraphPath(params.from, params.to, path17), path17);
+        }
+        const { callers } = await getCallGraphData(root, HOST2, {
+          name: params.to,
+          direction: "callers"
+        });
+        const directEdge = callers.find((edge) => edge.fromSymbolName === params.from);
+        if (directEdge) {
+          const location = directEdge.fromSymbolFilePath ? ` at ${directEdge.fromSymbolFilePath}:${directEdge.line}` : "";
+          return text2(
+            `Direct path: ${params.from} --${directEdge.callType}--> ${params.to}${location} (edge is ${directEdge.isResolved ? "resolved" : "unresolved"}).`,
+            path17
+          );
+        }
+        return text2(formatCallGraphPath(params.from, params.to, path17), path17);
+      }
+      if (params.symbol) {
+        const results2 = await implementationLookup(root, HOST2, params.symbol, {
+          limit: params.limit ?? 10,
+          fileType: params.fileType,
+          directory: params.directory
+        });
+        return text2(formatDefinitionLookup(results2, params.symbol), results2);
+      }
+      const results = await searchCodebase(root, HOST2, params.query, {
+        limit: params.limit ?? 10,
+        fileType: params.fileType,
+        directory: params.directory,
+        metadataOnly: true
+      });
+      if (results.length === 0) {
+        return text2("No matching code found. Try a different query or run index_status/index_codebase first.");
+      }
+      return text2(`Found ${results.length} locations for "${params.query}":
+
+${formatCodebasePeek(results)}`, results);
+    }
+  });
   pi.registerTool({
     name: "codebase_search",
     label: "Codebase Search",
-    description: "Semantic search over the indexed codebase. Describe behavior, not syntax.",
+    description: "Use this after codebase_context when you need semantic content, not just locations. Describe behavior, not syntax.",
     parameters: import_typebox2.Type.Object({
       query: import_typebox2.Type.String({ description: "Natural language description of what code you're looking for" }),
       limit: import_typebox2.Type.Optional(import_typebox2.Type.Number({ description: "Maximum results (default: 10)" })),
@@ -10674,7 +10752,7 @@ function codebaseIndexPiExtension(pi) {
   pi.registerTool({
     name: "codebase_peek",
     label: "Codebase Peek",
-    description: "Semantic search returning only metadata (file, lines, symbol) to save tokens.",
+    description: "LOW-TOKEN location-first retrieval. Prefer codebase_context first, then use this for cheap conceptual lookup.",
     parameters: import_typebox2.Type.Object({
       query: import_typebox2.Type.String(),
       limit: import_typebox2.Type.Optional(import_typebox2.Type.Number()),
@@ -10693,7 +10771,7 @@ function codebaseIndexPiExtension(pi) {
   pi.registerTool({
     name: "find_similar",
     label: "Find Similar Code",
-    description: "Find code similar to a snippet for duplicate detection and pattern discovery.",
+    description: "Find code similar to a snippet for duplicate detection, pattern discovery, and refactor planning.",
     parameters: import_typebox2.Type.Object({
       code: import_typebox2.Type.String({ description: "Code snippet to compare" }),
       limit: import_typebox2.Type.Optional(import_typebox2.Type.Number()),
@@ -10710,7 +10788,7 @@ function codebaseIndexPiExtension(pi) {
   pi.registerTool({
     name: "implementation_lookup",
     label: "Implementation Lookup",
-    description: "Find likely symbol definitions or implementations by name or natural language.",
+    description: "Find likely symbol definitions or implementations after codebase_context identifies a symbol.",
     parameters: import_typebox2.Type.Object({
       query: import_typebox2.Type.String(),
       limit: import_typebox2.Type.Optional(import_typebox2.Type.Number()),
@@ -10725,7 +10803,7 @@ function codebaseIndexPiExtension(pi) {
   pi.registerTool({
     name: "index_codebase",
     label: "Index Codebase",
-    description: "Build or refresh the semantic codebase index.",
+    description: "Build or refresh the semantic codebase index. Run index_status when freshness is unknown.",
     parameters: import_typebox2.Type.Object({
       force: import_typebox2.Type.Optional(import_typebox2.Type.Boolean({ default: false })),
       estimateOnly: import_typebox2.Type.Optional(import_typebox2.Type.Boolean({ default: false })),
@@ -10751,7 +10829,7 @@ function codebaseIndexPiExtension(pi) {
   pi.registerTool({
     name: "index_health_check",
     label: "Index Health Check",
-    description: "Garbage collect orphaned embeddings/chunks and report health.",
+    description: "Garbage collect orphaned embeddings/chunks and report index health status.",
     parameters: import_typebox2.Type.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
       const result = await runIndexHealthCheck(projectRoot2(ctx), HOST2);
@@ -10791,6 +10869,11 @@ function codebaseIndexPiExtension(pi) {
     }
   });
   registerPiCallGraphTools(pi);
+  pi.on("before_agent_start", (event) => ({
+    systemPrompt: `${event.systemPrompt}
+
+Check index_status first when index readiness is unknown. For repository questions, call codebase_context before search/grep/bash/read-style broad reads. Use implementation_lookup for known symbols and call_graph/call_graph_path after endpoints are identified for dependency flow. Avoid broad tool calls until semantic locations are known.`
+  }));
   pi.registerTool({
     name: "pr_impact",
     label: "PR Impact",