opencode-codebase-index 0.16.0 → 0.17.1

package/dist/index.js

@@ -1708,7 +1708,12 @@ function sameReclaimOwner(left, right) {
 }
 function publishJsonDirectory(finalPath, value) {
   const candidatePath = `${finalPath}.candidate.${process.pid}.${randomUUID()}`;
-  mkdirSync2(candidatePath, { mode: 448 });
+  try {
+    mkdirSync2(candidatePath, { mode: 448 });
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
+  }
   try {
     writeFileSync2(path7.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
       encoding: "utf-8",
@@ -1721,8 +1726,12 @@ function publishJsonDirectory(finalPath, value) {
       return true;
     } catch (error) {
       if (existsSync5(finalPath)) return false;
+      if (getErrorCode(error) === "ENOENT") return false;
       throw error;
     }
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") return false;
+    throw error;
   } finally {
     if (existsSync5(candidatePath)) rmSync(candidatePath, { recursive: true, force: true });
   }
@@ -6578,6 +6587,27 @@ function mergeTieredResults(symbolLane, hybridLane, limit) {
   }
   return out;
 }
+function selectChunksWithFileCoverage(chunks, limit) {
+  if (limit <= 0 || chunks.length === 0) {
+    return [];
+  }
+  if (chunks.length <= limit) {
+    return chunks;
+  }
+  if (limit === 1) {
+    return [chunks[Math.floor((chunks.length - 1) / 2)]];
+  }
+  const selected = [];
+  for (let index = 0; index < limit; index++) {
+    const sourceIndex = Math.round(index * (chunks.length - 1) / (limit - 1));
+    selected.push(chunks[sourceIndex]);
+  }
+  return selected;
+}
+function selectIndexableChunks(chunks, limit, semanticOnly) {
+  const indexableChunks = semanticOnly ? chunks.filter((chunk) => chunk.chunkType !== "other") : chunks;
+  return selectChunksWithFileCoverage(indexableChunks, limit);
+}
 function matchesSearchFilters(candidate, options, minScore) {
   if (candidate.score < minScore) return false;
   if (options?.fileType) {
@@ -8316,7 +8346,6 @@ var Indexer = class {
         const relativePath = path13.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
-      let fileChunkCount = 0;
       let chunksToProcess = parsed.chunks;
       if (this.config.indexing.fallbackToTextOnMaxChunks && chunksToProcess.length > this.config.indexing.maxChunksPerFile) {
         const changedFile = changedFiles.find((f) => f.path === parsed.path);
@@ -8325,13 +8354,12 @@ var Indexer = class {
           chunksToProcess = textChunks;
         }
       }
+      chunksToProcess = selectIndexableChunks(
+        chunksToProcess,
+        this.config.indexing.maxChunksPerFile,
+        this.config.indexing.semanticOnly
+      );
       for (const chunk of chunksToProcess) {
-        if (fileChunkCount >= this.config.indexing.maxChunksPerFile) {
-          break;
-        }
-        if (this.config.indexing.semanticOnly && chunk.chunkType === "other") {
-          continue;
-        }
         const id = generateChunkId(parsed.path, chunk);
         const contentHash = generateChunkHash(chunk);
         const existingContentHash = existingChunks.get(id);
@@ -8355,7 +8383,6 @@ var Indexer = class {
           blameSummary: blameMetadata.blameSummary
         });
         if (existingContentHash === contentHash) {
-          fileChunkCount++;
           continue;
         }
         const texts = createEmbeddingTexts(chunk, parsed.path, getSafeEmbeddingChunkTokenLimit(configuredProviderInfo)).map((text) => ({
@@ -8380,7 +8407,6 @@ var Indexer = class {
           contentHash,
           metadata
         });
-        fileChunkCount++;
       }
     }
     const retryableFailedChunks = this.collectRetryableFailedChunks(
@@ -9971,6 +9997,159 @@ function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot) {
 }
 
 // src/tools/utils.ts
+import { get_encoding } from "tiktoken";
+var MIN_CONTEXT_PACK_TOKEN_BUDGET = 128;
+var MAX_CONTEXT_PACK_TOKEN_BUDGET = 4e3;
+var DEFAULT_CONTEXT_PACK_TOKEN_BUDGET = 1200;
+var CONTEXT_TOKENIZER = get_encoding("cl100k_base");
+function clampContextPackTokenBudget(tokenBudget) {
+  if (tokenBudget === void 0 || !Number.isFinite(tokenBudget)) {
+    return DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
+  }
+  return Math.min(
+    MAX_CONTEXT_PACK_TOKEN_BUDGET,
+    Math.max(MIN_CONTEXT_PACK_TOKEN_BUDGET, Math.floor(tokenBudget))
+  );
+}
+function countContextTokens(text) {
+  return CONTEXT_TOKENIZER.encode(text).length;
+}
+function fitTextToContextBudget(text, tokenBudget) {
+  const normalizedBudget = clampContextPackTokenBudget(tokenBudget);
+  const tokenEstimate = countContextTokens(text);
+  if (tokenEstimate <= normalizedBudget) {
+    return {
+      text,
+      tokenBudget: normalizedBudget,
+      tokenEstimate,
+      truncated: false
+    };
+  }
+  const suffix = "\n...[truncated to context token budget]";
+  const codePoints = Array.from(text);
+  let low = 0;
+  let high = codePoints.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    const candidate = `${codePoints.slice(0, middle).join("").trimEnd()}${suffix}`;
+    if (countContextTokens(candidate) <= normalizedBudget) low = middle;
+    else high = middle - 1;
+  }
+  const fitted = `${codePoints.slice(0, low).join("").trimEnd()}${suffix}`;
+  return {
+    text: fitted,
+    tokenBudget: normalizedBudget,
+    tokenEstimate: countContextTokens(fitted),
+    truncated: true
+  };
+}
+function normalizedLineRange(result) {
+  return result.startLine <= result.endLine ? { start: result.startLine, end: result.endLine } : { start: result.endLine, end: result.startLine };
+}
+function rankContextCandidates(results) {
+  return results.map((result, originalIndex) => ({ result, originalIndex })).sort((left, right) => right.result.score - left.result.score || left.originalIndex - right.originalIndex);
+}
+function deduplicateContextCandidates(candidates) {
+  const acceptedByFile = /* @__PURE__ */ new Map();
+  const deduplicated = [];
+  for (const { result } of candidates) {
+    const range = normalizedLineRange(result);
+    const accepted = acceptedByFile.get(result.filePath) ?? [];
+    if (accepted.some((item) => item.start <= range.end && range.start <= item.end)) {
+      continue;
+    }
+    accepted.push(range);
+    acceptedByFile.set(result.filePath, accepted);
+    deduplicated.push(result);
+  }
+  return deduplicated;
+}
+function diversifyContextCandidates(results) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const bucket = byFile.get(result.filePath) ?? [];
+    bucket.push(result);
+    byFile.set(result.filePath, bucket);
+  }
+  const files = [...byFile.keys()];
+  const diversified = [];
+  for (let depth = 0; diversified.length < results.length; depth += 1) {
+    for (const file of files) {
+      const result = byFile.get(file)?.[depth];
+      if (result) diversified.push(result);
+    }
+  }
+  return diversified;
+}
+function compactEvidenceValue(value, maxChars) {
+  const characters = [...value];
+  if (characters.length <= maxChars) return value;
+  return `\u2026${characters.slice(-(maxChars - 1)).join("")}`;
+}
+function formatContextEvidence(result, index) {
+  const symbol = result.name ? ` ${JSON.stringify(compactEvidenceValue(result.name, 80))}` : "";
+  const path24 = compactEvidenceValue(result.filePath, 120);
+  return `[${index}] ${result.chunkType}${symbol} in ${path24}:${result.startLine}-${result.endLine} (score ${result.score.toFixed(2)})`;
+}
+function formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, budgetOmittedCount) {
+  const lines = selected.map((result, index) => formatContextEvidence(result, index + 1));
+  const notes = [];
+  if (duplicateCount > 0) notes.push(`${duplicateCount} overlapping duplicate${duplicateCount === 1 ? "" : "s"} removed`);
+  if (limitOmittedCount > 0) notes.push(`${limitOmittedCount} additional result${limitOmittedCount === 1 ? "" : "s"} excluded by result limit`);
+  if (budgetOmittedCount > 0) notes.push(`${budgetOmittedCount} additional result${budgetOmittedCount === 1 ? "" : "s"} omitted by token budget`);
+  const footer = notes.length > 0 ? `Selected ${selected.length} of ${candidateCount} candidates; ${notes.join("; ")}.` : `Selected ${selected.length} of ${candidateCount} candidates.`;
+  return `${heading}
+
+${lines.join("\n")}
+
+${footer}`;
+}
+function buildContextPack(results, options = {}) {
+  const requestedTokenBudget = options.tokenBudget ?? DEFAULT_CONTEXT_PACK_TOKEN_BUDGET;
+  const tokenBudget = clampContextPackTokenBudget(options.tokenBudget);
+  const heading = compactEvidenceValue(options.heading?.trim() || "Codebase evidence", 160);
+  const maxResults = Math.max(0, Math.floor(options.maxResults ?? results.length));
+  const candidateCount = results.length;
+  const deduplicated = deduplicateContextCandidates(rankContextCandidates(results));
+  const diversified = diversifyContextCandidates(deduplicated);
+  const duplicateCount = candidateCount - deduplicated.length;
+  const selectable = diversified.slice(0, maxResults);
+  const limitOmittedCount = deduplicated.length - selectable.length;
+  let selected = [];
+  let text = formatContextPack(heading, selected, candidateCount, duplicateCount, limitOmittedCount, selectable.length);
+  for (let count = 1; count <= selectable.length; count += 1) {
+    const candidateSelection = selectable.slice(0, count);
+    const budgetOmittedCount2 = selectable.length - candidateSelection.length;
+    const candidateText = formatContextPack(
+      heading,
+      candidateSelection,
+      candidateCount,
+      duplicateCount,
+      limitOmittedCount,
+      budgetOmittedCount2
+    );
+    if (countContextTokens(candidateText) > tokenBudget) break;
+    selected = candidateSelection;
+    text = candidateText;
+  }
+  const fitted = fitTextToContextBudget(text, tokenBudget);
+  const budgetOmittedCount = selectable.length - selected.length;
+  const omittedCount = candidateCount - selected.length;
+  return {
+    requestedTokenBudget,
+    tokenBudget,
+    text: fitted.text,
+    tokenEstimate: fitted.tokenEstimate,
+    results: selected,
+    candidateCount,
+    deduplicatedCount: deduplicated.length,
+    selectedCount: selected.length,
+    omittedCount,
+    duplicateCount,
+    limitOmittedCount,
+    budgetOmittedCount
+  };
+}
 var MAX_CONTENT_LINES = 30;
 function truncateContent(content) {
   const lines = content.split("\n");
@@ -12800,6 +12979,253 @@ var pr_impact = tool({
   }
 });
 
+// src/tools/symbol-inference.ts
+var IDENTIFIER_RE = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+var QUOTED_BACKTICK_RE = /`([^`]+)`/g;
+var QUOTED_SINGLE_RE = /'([^'\\]+)'/g;
+var QUOTED_DOUBLE_RE = /"([^"]+)"/g;
+var SYMBOL_LIKE_RE = /^(?:[A-Za-z_$][A-Za-z0-9_$]*)$/;
+var CAMEL_CASE_RE = /^[a-z_][A-Za-z0-9_$]*[A-Z][A-Za-z0-9_$]*$/;
+var PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9_$]*$/;
+var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*_[a-z0-9_]+$/;
+var DEFINITION_INTENT_RE = /\b(where|defined|definition|define|declaration|symbol|function|method|class|interface|type)\b/i;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "at",
+  "for",
+  "find",
+  "how",
+  "i",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "that",
+  "the",
+  "definition",
+  "show",
+  "to",
+  "where",
+  "which",
+  "what",
+  "you",
+  "your",
+  "with"
+]);
+function stripCallSuffix(token) {
+  return token.replace(/\(\s*\)$/, "");
+}
+function isLikelySymbolName(token) {
+  if (!SYMBOL_LIKE_RE.test(token)) {
+    return false;
+  }
+  if (STOP_WORDS.has(token.toLowerCase())) {
+    return false;
+  }
+  return CAMEL_CASE_RE.test(token) || PASCAL_CASE_RE.test(token) || SNAKE_CASE_RE.test(token);
+}
+function extractQuotedIdentifiers(query) {
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(QUOTED_BACKTICK_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  for (const match of query.matchAll(QUOTED_SINGLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  for (const match of query.matchAll(QUOTED_DOUBLE_RE)) {
+    const candidate = stripCallSuffix(match[1].trim());
+    if (candidate && isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  return [...identifiers];
+}
+function extractBareIdentifiers(query) {
+  const unquoted = query.replace(QUOTED_BACKTICK_RE, " ").replace(QUOTED_SINGLE_RE, " ").replace(QUOTED_DOUBLE_RE, " ");
+  const identifiers = /* @__PURE__ */ new Set();
+  for (const match of unquoted.matchAll(IDENTIFIER_RE)) {
+    const candidate = stripCallSuffix(match[0]);
+    if (isLikelySymbolName(candidate)) {
+      identifiers.add(candidate);
+    }
+  }
+  return [...identifiers];
+}
+function isSingleMeaningfulToken(query, symbol) {
+  const tokens = query.replace(/[`'"()]/g, " ").split(/[^A-Za-z0-9_$]+/).map((token) => token.trim().toLowerCase()).filter((token) => token.length > 0).filter((token) => !STOP_WORDS.has(token));
+  return tokens.length === 1 && tokens[0] === symbol.toLowerCase();
+}
+function inferExactSymbolFromQuery(query) {
+  const quoted = extractQuotedIdentifiers(query);
+  if (quoted.length === 1) {
+    return quoted[0];
+  }
+  if (quoted.length > 1) {
+    return void 0;
+  }
+  const candidates = extractBareIdentifiers(query);
+  if (candidates.length !== 1) {
+    return void 0;
+  }
+  const candidate = candidates[0];
+  if (DEFINITION_INTENT_RE.test(query)) {
+    return candidate;
+  }
+  if (isSingleMeaningfulToken(query, candidate)) {
+    return candidate;
+  }
+  return void 0;
+}
+
+// src/tools/context.ts
+var MIN_CONTEXT_RESULT_LIMIT = 1;
+var MAX_CONTEXT_RESULT_LIMIT = 100;
+var MIN_CONTEXT_PATH_DEPTH = 1;
+var MAX_CONTEXT_PATH_DEPTH = 100;
+function locations(results) {
+  return results.map((result) => ({
+    filePath: result.filePath,
+    startLine: result.startLine,
+    endLine: result.endLine,
+    score: result.score,
+    chunkType: result.chunkType,
+    name: result.name
+  }));
+}
+function packedResult(route, routedQuery, pack) {
+  return {
+    text: pack.text,
+    details: {
+      route,
+      routedQuery,
+      tokenBudget: pack.tokenBudget,
+      tokenEstimate: pack.tokenEstimate,
+      candidateCount: pack.candidateCount,
+      deduplicatedCount: pack.deduplicatedCount,
+      selectedCount: pack.selectedCount,
+      omittedCount: pack.omittedCount,
+      duplicateCount: pack.duplicateCount,
+      limitOmittedCount: pack.limitOmittedCount,
+      budgetOmittedCount: pack.budgetOmittedCount,
+      results: locations(pack.results)
+    }
+  };
+}
+async function resolveSearchContext(input, operations) {
+  const explicitSymbol = input.symbol ?? void 0;
+  const limit = input.limit ?? 10;
+  const tokenBudget = input.tokenBudget ?? void 0;
+  const lookupSymbol = explicitSymbol ?? inferExactSymbolFromQuery(input.query);
+  if (lookupSymbol) {
+    const definitions = await operations.lookup(lookupSymbol, MAX_CONTEXT_RESULT_LIMIT);
+    if (definitions.length > 0) {
+      return packedResult("definition", lookupSymbol, buildContextPack(definitions, {
+        tokenBudget,
+        maxResults: limit,
+        heading: `Definition evidence for ${JSON.stringify(lookupSymbol)}`
+      }));
+    }
+    if (explicitSymbol) {
+      const fitted = fitTextToContextBudget(
+        formatDefinitionLookup(definitions, lookupSymbol),
+        tokenBudget
+      );
+      return { text: fitted.text };
+    }
+  }
+  const results = await operations.search(input.query, MAX_CONTEXT_RESULT_LIMIT);
+  if (results.length === 0) {
+    const fitted = fitTextToContextBudget(
+      "No matching code found. Try a different query or run index_codebase first.",
+      tokenBudget
+    );
+    return { text: fitted.text };
+  }
+  return packedResult("conceptual", input.query, buildContextPack(results, {
+    tokenBudget,
+    maxResults: limit,
+    heading: `Codebase evidence for ${JSON.stringify(input.query)}`
+  }));
+}
+function fittedDetails(route, fitted) {
+  return {
+    route,
+    tokenBudget: fitted.tokenBudget,
+    tokenEstimate: fitted.tokenEstimate,
+    truncated: fitted.truncated
+  };
+}
+async function resolveCodebaseContext(projectRoot, host, input) {
+  const from = input.from ?? void 0;
+  const to = input.to ?? void 0;
+  const symbol = input.symbol ?? void 0;
+  const limit = input.limit ?? 10;
+  const maxDepth = input.maxDepth ?? 10;
+  const fileType = input.fileType ?? void 0;
+  const directory = input.directory ?? void 0;
+  const tokenBudget = input.tokenBudget ?? void 0;
+  if (from && to) {
+    const path24 = await getCallGraphPath(projectRoot, host, from, to, maxDepth);
+    if (path24.length > 0) {
+      const fitted2 = fitTextToContextBudget(
+        formatCallGraphPath(from, to, path24),
+        tokenBudget
+      );
+      return {
+        text: fitted2.text,
+        details: fittedDetails("path", fitted2)
+      };
+    }
+    const { callers } = await getCallGraphData(projectRoot, host, {
+      name: to,
+      direction: "callers"
+    });
+    const directEdge = callers.find((edge) => edge.fromSymbolName === from);
+    if (directEdge) {
+      const location = directEdge.fromSymbolFilePath ? ` at ${directEdge.fromSymbolFilePath}:${directEdge.line}` : "";
+      const fitted2 = fitTextToContextBudget(
+        `Direct path: ${from} --${directEdge.callType}--> ${to}${location} (edge is ${directEdge.isResolved ? "resolved" : "unresolved"}).`,
+        tokenBudget
+      );
+      return {
+        text: fitted2.text,
+        details: fittedDetails("direct-edge", fitted2)
+      };
+    }
+    const fitted = fitTextToContextBudget(
+      formatCallGraphPath(from, to, path24),
+      tokenBudget
+    );
+    return {
+      text: fitted.text,
+      details: fittedDetails("path", fitted)
+    };
+  }
+  return resolveSearchContext({ query: input.query, symbol, limit, tokenBudget }, {
+    lookup: (lookupSymbol, retrievalLimit) => implementationLookup(projectRoot, host, lookupSymbol, {
+      limit: retrievalLimit,
+      fileType,
+      directory
+    }),
+    search: (query, retrievalLimit) => searchCodebase(projectRoot, host, query, {
+      limit: retrievalLimit,
+      fileType,
+      directory,
+      metadataOnly: true
+    })
+  });
+}
+
 // src/tools/index.ts
 import { writeFileSync as writeFileSync5 } from "fs";
 import * as os5 from "os";
@@ -13531,6 +13957,23 @@ function initializeTools2(projectRoot, config) {
 function getIndexerForProject2(directory) {
   return getIndexerForProject(directory, DEFAULT_HOST);
 }
+var codebase_context = tool2({
+  description: "PREFERRED FIRST TOOL for repository questions. Returns a deduplicated, file-diverse evidence pack within tokenBudget. Provide from and to for dependency paths, symbol for definitions, or only query for conceptual discovery.",
+  args: {
+    query: z2.string().describe("The repository question or behavior to locate"),
+    from: z2.string().nullable().optional().describe("Source symbol for a dependency path"),
+    to: z2.string().nullable().optional().describe("Target symbol for a dependency path"),
+    symbol: z2.string().nullable().optional().describe("Exact symbol for authoritative definition lookup"),
+    limit: z2.number().int().min(MIN_CONTEXT_RESULT_LIMIT).max(MAX_CONTEXT_RESULT_LIMIT).nullable().optional().default(10).describe(`Maximum number of results (${MIN_CONTEXT_RESULT_LIMIT}-${MAX_CONTEXT_RESULT_LIMIT})`),
+    maxDepth: z2.number().int().min(MIN_CONTEXT_PATH_DEPTH).max(MAX_CONTEXT_PATH_DEPTH).nullable().optional().default(10).describe(`Maximum call-path traversal depth (${MIN_CONTEXT_PATH_DEPTH}-${MAX_CONTEXT_PATH_DEPTH})`),
+    fileType: z2.string().nullable().optional().describe("Filter by file extension"),
+    directory: z2.string().nullable().optional().describe("Filter by directory path"),
+    tokenBudget: z2.number().int().min(MIN_CONTEXT_PACK_TOKEN_BUDGET).max(MAX_CONTEXT_PACK_TOKEN_BUDGET).nullable().optional().default(DEFAULT_CONTEXT_PACK_TOKEN_BUDGET).describe(`Maximum response tokens (${MIN_CONTEXT_PACK_TOKEN_BUDGET}-${MAX_CONTEXT_PACK_TOKEN_BUDGET})`)
+  },
+  async execute(args, context) {
+    return (await resolveCodebaseContext(context?.worktree, DEFAULT_HOST, args)).text;
+  }
+});
 var codebase_peek = tool2({
   description: "Quick lookup of code locations by meaning. Returns only metadata (file, line, name, type) WITHOUT code content. Use this first to find WHERE code is, then use Read tool to examine specific files. Saves tokens by not returning full code blocks. Best for: discovery, navigation, finding multiple related locations.",
   args: {
@@ -14213,6 +14656,7 @@ var plugin = async ({ directory, worktree }) => {
     }
     return {
       tool: {
+        codebase_context,
         codebase_search,
         codebase_peek,
         index_codebase,