opencode-codebase-index 0.24.0 → 0.25.0

package/dist/cli.js

@@ -3596,6 +3596,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;
@@ -6820,6 +6840,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",
@@ -10866,6 +10889,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 += estimateTokens2(text);
+          }
+        }
+      }
+    }
+    return { filesCount, chunksCount, tokensToEmbed };
+  }
   async index(onProgress) {
     return this.withIndexMutationLease("index", async (recoveredOwners) => {
       return this.indexUnlocked(onProgress, recoveredOwners);
@@ -15369,6 +15456,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), {
@@ -18295,6 +18385,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) };
@@ -18622,6 +18713,7 @@ ${formatCodebasePeek(results)}`;
     {
       force: allowNullAsUndefined(z2.boolean().optional().default(false)).describe("Force reindex even if already indexed"),
       estimateOnly: allowNullAsUndefined(z2.boolean().optional().default(false)).describe("Only show cost estimate without indexing"),
+      dryRun: allowNullAsUndefined(z2.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: allowNullAsUndefined(z2.boolean().optional().default(false)).describe("Show detailed info about skipped files and parsing failures")
     },
     async (args) => {
@@ -18836,7 +18928,7 @@ ${formatSearchResults(results)}` }] };
 // src/adapters/mcp/server.ts
 function getServerInstructions(host) {
   const hostText = `host ${host}`;
-  return `This MCP server is the preferred codebase-understanding path for ${hostText}. Start a repository task with index_status when index readiness or freshness is unknown. Use codebase_context as the preferred first entry point because it returns a token-budgeted location pack and routes to definitions or call-graph helpers when symbol intent is present. Keep the default tokenBudget for normal discovery, then use implementation_lookup, codebase_search, or a targeted file read only for selected locations that need source content. Use codebase_peek for direct conceptual location lookup. For exact identifiers or exhaustive matches, use grep. After identifying symbols, use call_graph or call_graph_path to trace dependencies. If the index is unavailable, run index_codebase, then retry the retrieval tool.`;
+  return `This MCP server is the preferred codebase-understanding path for ${hostText}. Start a repository task with index_status when index readiness or freshness is unknown. Use codebase_context as the preferred first entry point because it returns a token-budgeted location pack and routes to definitions or call-graph helpers when symbol intent is present. For code changes with a known or suspected symbol target, optionally call codebase_edit_context as a compact pre-edit step for bounded source plus direct callers and callees before broad file reads. Keep the default tokenBudget for normal discovery, then use implementation_lookup, codebase_search, or a targeted file read only for selected locations that need source content. Use codebase_peek for direct conceptual location lookup. For exact identifiers or exhaustive matches, use grep. After identifying symbols, use call_graph or call_graph_path to trace dependencies. If the index is unavailable, run index_codebase, then retry the retrieval tool.`;
 }
 function createMcpServer(projectRoot, config, host) {
   const server = new McpServer({
@@ -22254,6 +22346,7 @@ function parseIndexArgs(argv, cwd) {
   let config;
   let force = false;
   let estimateOnly = false;
+  let dryRun = false;
   let verbose = false;
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -22291,13 +22384,16 @@ function parseIndexArgs(argv, cwd) {
       host = parseHostMode(value);
       continue;
     }
-    if (arg === "--force" || arg === "--estimate-only" || arg === "--verbose") {
+    if (arg === "--force" || arg === "--estimate-only" || arg === "--dry-run" || arg === "--verbose") {
       if (arg === "--force") {
         force = true;
       }
       if (arg === "--estimate-only") {
         estimateOnly = true;
       }
+      if (arg === "--dry-run") {
+        dryRun = true;
+      }
       if (arg === "--verbose") {
         verbose = true;
       }
@@ -22308,7 +22404,7 @@ function parseIndexArgs(argv, cwd) {
     }
     throw new Error(`Unknown index option: ${arg}`);
   }
-  return { project, host, config, force, estimateOnly, verbose };
+  return { project, host, config, force, estimateOnly, dryRun, verbose };
 }
 function loadCliRawConfig(args) {
   return args.config ? loadConfigFile(args.config) : loadMergedConfig(args.project, args.host);
@@ -22325,6 +22421,7 @@ Options:
   --config <path>        Explicit JSON config path
   --force                Rebuild index even if already up to date
   --estimate-only        Estimate indexing cost only
+  --dry-run              Parse only; report the exact embedding token total without indexing
   --verbose              Include detailed final index statistics
   --help                 Show this message
 
@@ -22520,6 +22617,7 @@ async function handleIndexCommand(argv, cwd, deps = {}) {
     const indexArgs = {
       force: parsedArgs.force,
       estimateOnly: parsedArgs.estimateOnly,
+      dryRun: parsedArgs.dryRun,
       verbose: parsedArgs.verbose
     };
     const result = await runIndex(parsedArgs.project, parsedArgs.host, indexArgs, (title, metadata) => {