opencode-codebase-index 0.24.0 → 0.25.0

package/dist/index.js

@@ -6576,6 +6576,26 @@ function formatCostEstimate(estimate) {
 \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
 `;
 }
+function formatDryRunEstimate(estimate) {
+  return `Dry run: parsed the file set to measure the embedding workload. No embedding requests were made and the index was not changed.
+
+  Files to embed:   ${estimate.filesCount.toLocaleString()}
+  Chunks to embed:  ${estimate.chunksCount.toLocaleString()}
+  Tokens to embed:  ${estimate.tokensToEmbed.toLocaleString()}
+
+The "Tokens to embed" value uses the local estimateTokens(text) = ceil(len/4). It
+matches the live "Tokens used" counter only for providers that report usage on the
+same basis (ollama); for providers that report a server tokenizer count (OpenAI,
+Gemini, custom) it is only an estimate.
+
+For a matching provider and a project-scoped force index, the force pass clears its
+own cached embeddings, so the live counter climbs to this number. A force index on a
+shared global index can reuse cached embeddings from other projects, and an
+incremental index counts cached chunks that are not re-embedded; in both cases this
+number is an upper bound on the live counter, so a progress percent against this
+total tops out below 100%.
+`;
+}
 function formatBytes(bytes) {
   if (bytes === 0) return "0 B";
   const k = 1024;
@@ -8850,6 +8870,9 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "enum_declaration",
   "function_definition",
   "class_definition",
+  // Ruby module/class symbols that are declaration-bearing and navigable.
+  "class",
+  "module",
   "class_specifier",
   "struct_specifier",
   "namespace_definition",
@@ -12450,6 +12473,70 @@ var Indexer = class _Indexer {
     );
     return createCostEstimate(files, configuredProviderInfo);
   }
+  // Dry-run counterpart to index()/forceIndex(): parse the real file set and sum
+  // estimateTokens over the embedding text of every indexable chunk, without
+  // calling the embedding provider or writing to the index. Read-only and
+  // lock-free (mirrors estimateCost). The token sum is the exact value "Tokens
+  // used" climbs to for a force index (cache bypassed); for an incremental it is
+  // an upper bound because cached chunks are counted here but not re-embedded.
+  // Used by index_codebase(dryRun:true) to give a stable, monotonic progress
+  // denominator that matches the live "Tokens used" basis.
+  async dryRunCost() {
+    const { configuredProviderInfo } = await this.ensureInitialized();
+    const maxChunkTokens = getSafeEmbeddingChunkTokenLimit(configuredProviderInfo);
+    const includePatterns = [...this.config.include, ...this.config.additionalInclude];
+    const { files } = await collectFiles(
+      this.materializedProjectRoot,
+      includePatterns,
+      this.config.exclude,
+      this.config.indexing.maxFileSize,
+      this.getMaterializedKnowledgeBases(),
+      { maxDepth: this.config.indexing.maxDepth, maxFilesPerDirectory: this.config.indexing.maxFilesPerDirectory }
+    );
+    let filesCount = 0;
+    let chunksCount = 0;
+    let tokensToEmbed = 0;
+    for (const batch of iterateOrderedFileBatches(files, (f) => f.size, this.fileBatchLimits)) {
+      const loadedFiles = await Promise.all(batch.map(async (f) => {
+        try {
+          return {
+            path: this.toStoredFilePath(f.path),
+            content: await fsPromises3.readFile(f.path, "utf-8")
+          };
+        } catch {
+          return null;
+        }
+      }));
+      const readable = loadedFiles.filter(
+        (f) => f !== null
+      );
+      filesCount += readable.length;
+      const contentByPath = new Map(readable.map((f) => [f.path, f.content]));
+      const parsedFiles = parseFiles(readable, this.config.indexing.linesPerChunk);
+      for (const parsed of parsedFiles) {
+        let chunksToProcess = parsed.chunks;
+        if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
+          const content = contentByPath.get(parsed.path);
+          if (content !== void 0) {
+            chunksToProcess = parseFileAsText(parsed.path, content, this.config.indexing.linesPerChunk);
+          }
+        }
+        chunksToProcess = selectIndexableChunks(
+          chunksToProcess,
+          this.config.indexing.maxChunksPerFile,
+          this.config.indexing.semanticOnly
+        );
+        for (const chunk of chunksToProcess) {
+          const texts = createEmbeddingTexts(chunk, parsed.path, maxChunkTokens);
+          chunksCount += 1;
+          for (const text of texts) {
+            tokensToEmbed += estimateTokens(text);
+          }
+        }
+      }
+    }
+    return { filesCount, chunksCount, tokensToEmbed };
+  }
   async index(onProgress) {
     return this.withIndexMutationLease("index", async (recoveredOwners) => {
       return this.indexUnlocked(onProgress, recoveredOwners);
@@ -15003,6 +15090,9 @@ async function runIndexCodebase(projectRoot, host, args, onProgress) {
     if (args.estimateOnly) {
       return { kind: "estimate", estimate: await indexer.estimateCost() };
     }
+    if (args.dryRun) {
+      return { kind: "dryrun", dryrun: await indexer.dryRunCost() };
+    }
     const coordinated = runCoordinatedIndex(root, host, args.force ?? false, (progress) => {
       if (onProgress) {
         void onProgress(formatProgressTitle(progress), {
@@ -18843,6 +18933,7 @@ async function executeCodebaseEditContext(projectRoot, host, args) {
 async function executeIndexCodebase(projectRoot, host, args, onProgress) {
   const result = await runIndexCodebase(projectRoot, host, args, onProgress);
   if (result.kind === "estimate") return { text: formatCostEstimate(result.estimate) };
+  if (result.kind === "dryrun") return { text: formatDryRunEstimate(result.dryrun) };
   if (result.kind === "busy") return { text: result.text, isError: true };
   if (result.kind === "message") return { text: result.text };
   return { text: formatIndexStats(result.stats, args.verbose ?? false) };
@@ -19707,6 +19798,7 @@ var index_codebase = tool({
   args: {
     force: z3.boolean().optional().default(false).describe("Force reindex even if already indexed"),
     estimateOnly: z3.boolean().optional().default(false).describe("Only show cost estimate without indexing"),
+    dryRun: z3.boolean().optional().default(false).describe("Parse the file set and report the exact embedding token total without indexing. Read-only; the index is not changed. The total is the value 'Tokens used' climbs to for a force index (and an upper bound for an incremental)."),
     verbose: z3.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
   },
   async execute(args, context) {
@@ -20307,6 +20399,7 @@ function assessRoutingIntent(text) {
   };
 }
 function buildRoutingHint(assessment, status, includeGraphHandoff = false) {
+  const hasSymbolCue = hasIdentifierShape(assessment.text) || containsQuotedIdentifier(assessment.text);
   if (assessment.intent === "definition_lookup") {
     if (!status || !status.indexed || status.compatibility?.compatible === false) {
       return "For this turn, if you need a symbol definition, check `index_status` first and run `index_codebase` if the index is missing or incompatible. Then use `implementation_lookup` for the definition site. Use `grep` for exhaustive literal matches.";
@@ -20316,12 +20409,13 @@ function buildRoutingHint(assessment, status, includeGraphHandoff = false) {
   if (assessment.intent !== "local_conceptual" && assessment.intent !== "local_broad_task") {
     return null;
   }
+  const preEditHint = assessment.intent === "local_broad_task" && hasSymbolCue ? " If a likely target symbol is already known or strongly suspected, consider optional `codebase_edit_context` as a compact pre-edit next step for bounded source plus direct callers and callees." : "";
   if (!status || !status.indexed || status.compatibility?.compatible === false) {
     const graphHandoff2 = includeGraphHandoff ? " Use graph tools after semantic discovery identifies relevant symbols." : "";
-    return `For this turn, if local code discovery by behavior is needed, check \`index_status\` first and run \`index_codebase\` if the index is missing or incompatible.${graphHandoff2} Then use \`codebase_context\` as the first local repository lookup. Use \`grep\` for exact identifiers or exhaustive matches.`;
+    return `For this turn, if local code discovery by behavior is needed, check \`index_status\` first and run \`index_codebase\` if the index is missing or incompatible.${graphHandoff2} Then use \`codebase_context\` as the first local repository lookup. Use \`grep\` for exact identifiers or exhaustive matches.${preEditHint}`;
   }
   const graphHandoff = includeGraphHandoff ? " before graph tools such as `call_graph`, `call_graph_path`, `pr_impact`, or OMO CodeGraph" : "";
-  return `For this turn, prefer \`codebase_context\` for local code discovery, then use \`codebase_peek\` for metadata and \`codebase_search\` when you need implementation content${graphHandoff}. Use \`grep\` for exact identifiers or exhaustive matches.`;
+  return `For this turn, prefer \`codebase_context\` for local code discovery, then use \`codebase_peek\` for metadata and \`codebase_search\` when you need implementation content${graphHandoff}. Use \`grep\` for exact identifiers or exhaustive matches.${preEditHint}`;
 }
 var RoutingHintController = class {
   constructor(getStatus, maxSessions = 200, includeGraphHandoff = false) {
@@ -20363,7 +20457,7 @@ var RoutingHintController = class {
     if (!state || !state.pendingHint) {
       return;
     }
-    if (toolName === "codebase_context" || toolName === "codebase_peek" || toolName === "codebase_search" || toolName === "implementation_lookup" || toolName === "index_status" || toolName === "index_codebase") {
+    if (toolName === "codebase_context" || toolName === "codebase_edit_context" || toolName === "codebase_peek" || toolName === "codebase_search" || toolName === "implementation_lookup" || toolName === "index_status" || toolName === "index_codebase") {
       state.pendingHint = false;
       state.updatedAt = Date.now();
       this.sessionState.set(sessionID, state);