@octocodeai/octocode-tools-core 18.1.2 → 18.2.0

package/dist/tools/local_analyze_graph/analysisTypes.d.ts

@@ -0,0 +1,46 @@
+import type { WalkResult } from '../../graph/buildFileGraph.js';
+export type GraphOperation = 'deadCode' | 'cycles' | 'dependencies' | 'dependents' | 'path' | 'reachability';
+export interface AnalyzeGraphQuery {
+    operation: GraphOperation;
+    path: string;
+    file?: string;
+    target?: string;
+    depth?: number;
+    entrypoints?: string[];
+    includeTests?: boolean;
+    excludeDir?: string[];
+    maxFiles?: number;
+    limit?: number;
+    page?: number;
+    pageSize?: number;
+}
+export interface AnalyzeGraphOutput {
+    status?: 'empty' | 'error';
+    error?: string;
+    errorCode?: string;
+    operation: GraphOperation;
+    path: string;
+    filesScanned?: number;
+    filesSkipped?: number;
+    truncated?: boolean;
+    terminalLimit?: boolean;
+    partialReasons?: Array<'maxFiles' | 'limit' | 'filesSkipped'>;
+    totalAvailable?: number;
+    results: Array<Record<string, unknown>>;
+    summary?: Record<string, unknown>;
+    pagination?: {
+        currentPage: number;
+        totalPages: number;
+        entriesPerPage: number;
+        totalEntries: number;
+        hasMore: boolean;
+        outOfRange?: boolean;
+    };
+    next?: Record<string, unknown>;
+    warnings?: string[];
+    confidence?: 'low';
+    [key: string]: unknown;
+}
+export interface AnalyzeGraphContext {
+    getGraph?: (path: string, excludeDir: string[], maxFiles: number) => WalkResult | Promise<WalkResult>;
+}

package/dist/tools/local_analyze_graph/analyzeGraph.d.ts

@@ -0,0 +1,3 @@
+import type { AnalyzeGraphContext, AnalyzeGraphOutput, AnalyzeGraphQuery } from './analysisTypes.js';
+export declare function summarizeEntrypoints(entrypoints: string[]): Record<string, unknown>;
+export declare function analyzeGraph(query: AnalyzeGraphQuery, context?: AnalyzeGraphContext): Promise<AnalyzeGraphOutput>;

package/dist/tools/{local_dead_code → local_analyze_graph}/deadCodeScan.d.ts

@@ -1,3 +1,4 @@
+import { type WalkResult } from '../../graph/buildFileGraph.js';
 import type { DeadClusterOutput, DeadExportOutput, FindDeadCodeQuery as StrictFindDeadCodeQuery } from './scheme.js';
 import type { WithOptionalMeta } from '../../types/execution.js';
 type FindDeadCodeQuery = WithOptionalMeta<StrictFindDeadCodeQuery>;
@@ -22,5 +23,5 @@ export interface DeadCodeScanResult {
      */
     confidence?: 'low';
 }
-export declare function scanForDeadCode(rootAbsolutePath: string, query: FindDeadCodeQuery): DeadCodeScanResult;
+export declare function scanForDeadCode(rootAbsolutePath: string, query: FindDeadCodeQuery, builtGraph?: WalkResult): Promise<DeadCodeScanResult>;
 export {};

package/dist/tools/{local_dead_code → local_analyze_graph}/entrypoints.d.ts

@@ -1,3 +1,4 @@
+export declare function isTestFilePath(file: string): boolean;
 /**
  * Resolve entrypoint files: explicit paths win; otherwise auto-detect from
  * package.json (main/exports/bin, plus file-looking tokens inside `scripts`

package/dist/tools/local_analyze_graph/execution.d.ts

@@ -0,0 +1,4 @@
+import type { CallToolResult } from '@modelcontextprotocol/server';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+import { type AnalyzeGraphQuery } from './scheme.js';
+export declare function executeAnalyzeGraph(args: ToolExecutionArgs<AnalyzeGraphQuery>): Promise<CallToolResult>;

package/dist/tools/local_analyze_graph/pagination.d.ts

@@ -0,0 +1,3 @@
+import type { AnalyzeGraphOutput, AnalyzeGraphQuery } from './analysisTypes.js';
+export declare function paginateGraphResults(items: Array<Record<string, unknown>>, query: AnalyzeGraphQuery): Pick<AnalyzeGraphOutput, 'results' | 'pagination' | 'truncated' | 'partialReasons' | 'totalAvailable'>;
+export declare function finalizeGraphOutput(output: AnalyzeGraphOutput, query: AnalyzeGraphQuery, scanTruncated: boolean, why: string): AnalyzeGraphOutput;

package/dist/tools/{local_dead_code → local_analyze_graph}/retention.d.ts

@@ -1,4 +1,4 @@
-import type { FileFacts } from './types.js';
+import type { FileFacts } from '../../graph/types.js';
 export declare function bindingKey(file: string, name: string): string;
 /**
  * Symbol-level liveness for one file's exported declarations.

package/dist/tools/{local_dead_code → local_analyze_graph}/scheme.d.ts

@@ -1,13 +1,14 @@
 import { z } from 'zod';
-import { FindDeadCodeQuerySchema as CoreFindDeadCodeQuerySchema } from '@octocodeai/octocode-core/schemas';
 import type { LocalItemPagination, ToolContinuation } from '../../scheme/pagination.js';
-export type FindDeadCodeQuery = z.infer<typeof CoreFindDeadCodeQuerySchema>;
-export declare const LocalFindDeadCodeQuerySchema: z.ZodType<FindDeadCodeQuery>;
-export declare const LocalFindDeadCodeBulkQuerySchema: z.ZodObject<{
+import { LocalAnalyzeGraphQuerySchema } from '../../toolContract/schemas.js';
+export { LocalAnalyzeGraphQuerySchema };
+export type AnalyzeGraphQuery = z.infer<typeof LocalAnalyzeGraphQuerySchema>;
+export declare const LocalAnalyzeGraphBulkQuerySchema: z.ZodObject<{
     responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
+export type GraphOperation = AnalyzeGraphQuery['operation'];
 export type DeadCodeReason = 'unreachable-file' | 'unreferenced-export' | 'dead-cluster';
 export interface DeadExportOutput {
     file: string;
@@ -16,14 +17,6 @@ export interface DeadExportOutput {
     line: number;
     reason: DeadCodeReason;
     clusterId?: number;
-    /**
-     * Only on `reason:"unreferenced-export"` — which negative-evidence path
-     * concluded "dead", so agents know which candidates to LSP-verify first:
-     * - `"reexport-chain"`: the binding IS re-exported somewhere, but every
-     *   chain terminated without a real consumer — the most fragile verdict.
-     * - `"lexical-count"`: no import and no unexplained same-file occurrence
-     *   beyond the declaration itself.
-     */
     viaHeuristic?: 'lexical-count' | 'reexport-chain';
 }
 export interface DeadClusterOutput {
@@ -31,6 +24,30 @@ export interface DeadClusterOutput {
     files: string[];
     reason: string;
 }
+export interface AnalyzeGraphOutput {
+    status?: 'empty' | 'error';
+    error?: string;
+    errorCode?: string;
+    rawResponseChars?: number;
+    operation?: GraphOperation;
+    path?: string;
+    filesScanned?: number;
+    filesSkipped?: number;
+    truncated?: boolean;
+    terminalLimit?: boolean;
+    partialReasons?: Array<'maxFiles' | 'limit' | 'filesSkipped'>;
+    totalAvailable?: number;
+    results?: Array<Record<string, unknown>>;
+    summary?: Record<string, unknown>;
+    pagination?: LocalItemPagination;
+    next?: Record<string, ToolContinuation>;
+    warnings?: string[];
+    confidence?: 'low';
+    [key: string]: unknown;
+}
+export type FindDeadCodeQuery = Extract<AnalyzeGraphQuery, {
+    operation: 'deadCode';
+}> extends infer T ? T extends object ? Omit<T, 'operation'> : never : never;
 export interface FindDeadCodeOutput {
     status?: 'empty' | 'error';
     error?: string;
@@ -44,8 +61,7 @@ export interface FindDeadCodeOutput {
     deadClusters?: DeadClusterOutput[];
     pagination?: LocalItemPagination;
     next?: Record<string, ToolContinuation>;
-    /** See `DeadCodeScanResult.confidence` — present (always `"low"`) only when
-     * `entrypointsResolved` came entirely from the test-file heuristic. */
     confidence?: 'low';
+    warnings?: string[];
     [key: string]: unknown;
 }

package/dist/tools/local_fetch_content/execution.d.ts

@@ -1,4 +1,4 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/server';
 import { type FetchContentQuery } from './scheme.js';
 import type { ToolExecutionArgs } from '../../types/execution.js';
 export declare function executeFetchContent(args: ToolExecutionArgs<FetchContentQuery>): Promise<CallToolResult>;

package/dist/tools/local_fetch_content/scheme.d.ts

@@ -18,9 +18,7 @@ export declare const LocalFetchContentQuerySchema: z.ZodObject<{
         standard: "standard";
         symbols: "symbols";
     }>>;
-    id: z.ZodOptional<z.ZodString>;
-    mainResearchGoal: z.ZodOptional<z.ZodString>;
-    researchGoal: z.ZodOptional<z.ZodString>;
+    goal: z.ZodOptional<z.ZodString>;
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type FetchContentQuery = z.infer<typeof LocalFetchContentQuerySchema> & {
@@ -30,7 +28,7 @@ export declare const LocalFetchContentBulkQuerySchema: z.ZodObject<{
     responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export interface FileContentMatchRange {
     start: number;
     end: number;

package/dist/tools/local_find_files/execution.d.ts

@@ -1,4 +1,4 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/server';
 import { type FindFilesQuery } from './scheme.js';
 import type { ToolExecutionArgs } from '../../types/execution.js';
 export declare function executeFindFiles(args: ToolExecutionArgs<FindFilesQuery>): Promise<CallToolResult>;

package/dist/tools/local_find_files/findFiles.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { FindFilesQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { FindFilesQuerySchema } from '../../toolContract/schemas.js';
 import type { LocalFindFilesToolResult } from '@octocodeai/octocode-core/extra-types';
 type UpstreamFindFilesQuery = z.infer<typeof FindFilesQuerySchema>;
 import type { WithOptionalMeta } from '../../types/execution.js';

package/dist/tools/local_find_files/findFilesNext.d.ts

@@ -1,6 +1,6 @@
 import type { LocalFindFilesEntry } from '@octocodeai/octocode-core/types';
 type FindFilesNextCall = {
-    tool: 'localGetFileContent' | 'localViewStructure';
+    tool: 'localGetFileContent' | 'local.tree';
     query: Record<string, unknown>;
     why: string;
     confidence?: 'exact' | 'high' | 'medium' | 'low';
@@ -10,7 +10,7 @@ export type FindFilesNextMap = {
     viewStructure?: FindFilesNextCall;
 };
 /**
- * Build per-result continuation hints for a localFindFiles response: point the
+ * Build per-result continuation hints for a local files response: point the
  * agent at exact content for the first matched file, or into the first matched
  * directory when the page is all directories. `nextPage` (pagination) is added
  * separately by the caller.
@@ -20,7 +20,7 @@ export type FindFilesNextMap = {
  * SKIP_TRAVERSAL_KEYS in utils/response/pathRelativize.ts), so the hint stays
  * directly callable with no manual path conversion. Meta-free by construction:
  * queries are built from the entry path alone, never spread from the caller
- * query, so no auto-filled id/researchGoal/reasoning can leak in.
+ * query, so no auto-filled goal/reasoning can leak in.
  */
 export declare function buildFindFilesNextMap(files: readonly LocalFindFilesEntry[]): FindFilesNextMap | undefined;
 export {};

package/dist/tools/local_find_files/scheme.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { FindFilesQuerySchema as CoreFindFilesQuerySchema } from '@octocodeai/octocode-core/schemas';
+import { FindFilesQuerySchema as CoreFindFilesQuerySchema } from '../../toolContract/schemas.js';
 import type { LocalItemPagination, ToolContinuation } from '../../scheme/pagination.js';
 import type { BulkToolOutput } from '../../types/toolOutput.js';
 export type FindFilesQuery = Omit<z.infer<typeof CoreFindFilesQuerySchema>, 'regexType'>;
@@ -8,7 +8,7 @@ export declare const LocalFindFilesBulkQuerySchema: z.ZodObject<{
     responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export interface LocalFindFilesEntryOutput {
     name?: string;
     path?: string;
@@ -24,5 +24,9 @@ export interface LocalFindFilesData {
     summary?: string;
     pagination?: LocalItemPagination;
     next?: Record<string, ToolContinuation>;
+    terminalLimit?: boolean;
+    truncated?: boolean;
+    partialReasons?: Array<'limit' | 'walkLimit'>;
+    totalAvailable?: number;
 }
 export type LocalFindFilesOutput = BulkToolOutput<LocalFindFilesData>;

package/dist/tools/local_ripgrep/captureBudget.d.ts

@@ -22,4 +22,5 @@ export type MetavarRange = {
 export declare function budgetCaptures(metavars: Record<string, string[]> | undefined | null, metavarRanges: Record<string, MetavarRange[]> | undefined | null, captureText: boolean): {
     metavars?: Record<string, string[]>;
     metavarRanges?: Record<string, MetavarRange[]>;
+    capturesTruncated?: true;
 };

package/dist/tools/local_ripgrep/execution.d.ts

@@ -1,4 +1,4 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/server';
 import { type RipgrepQuery } from './scheme.js';
 import type { ToolExecutionArgs } from '../../types/execution.js';
 export { finalizeRipgrepResult } from './ripgrepResultBuilder.js';

package/dist/tools/local_ripgrep/rankingProfile/rankingLexical.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pure lexical helpers shared by ranking result orchestration and scoring.
+ *
+ * This leaf module must not import either rankingResults or rankingScoring:
+ * keeping those dependencies one-way prevents ESM initialization cycles.
+ */
+import type { RankingProfileId } from './rankingProfiles.js';
+export declare function matchesAny(patterns: readonly RegExp[], line: string): boolean;
+export declare function escapeRegex(s: string): string;
+/** A search whose keyword is a single bare identifier — the only case where
+ * whole-word/substring line-exactness is meaningful. */
+export declare function isPlainIdentifierKeyword(keyword?: string): boolean;
+/** Pick the line within a context snippet that actually contains the query. */
+export declare function matchedLineOf(snippet: string, token: string | undefined, caseSensitive?: boolean): string;
+type LexicalCategory = 'comment' | 'string' | 'code';
+/** Conservative fallback used when grammar-accurate AST kind is unavailable. */
+export declare function lexicalCategoryOf(line: string, token: string | undefined, profileId: RankingProfileId, caseSensitive?: boolean): LexicalCategory;
+/** Whether byte index index falls inside a quoted region of the line. */
+export declare function isIndexInsideString(line: string, index: number): boolean;
+export {};

package/dist/tools/local_ripgrep/rankingProfile/rankingResults.d.ts

@@ -10,7 +10,7 @@
  * `../rankingProfile.ts` for the full contract.
  */
 import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
-import type { RankingProfileId, RankSort } from './rankingProfiles.js';
+import type { RankSort } from './rankingProfiles.js';
 import type { FileScore, RankContext } from './rankingScoring.js';
 export interface RankResult {
     files: LocalSearchCodeFile[];
@@ -29,20 +29,3 @@ export declare function rankFiles(files: LocalSearchCodeFile[], sort: RankSort,
     candidateCap?: number;
     sortReverse?: boolean;
 }): RankResult;
-export declare function matchesAny(patterns: readonly RegExp[], line: string): boolean;
-export declare function escapeRegex(s: string): string;
-/** A search whose keyword is a single bare identifier — the only case where
- * whole-word/substring line-exactness is meaningful (regex/multi-term patterns
- * make the extracted token an arbitrary fragment). */
-export declare function isPlainIdentifierKeyword(keyword?: string): boolean;
-/** Pick the line within a (possibly multi-line context) snippet that actually
- * contains the query token; fall back to the first non-empty line. */
-export declare function matchedLineOf(snippet: string, token: string | undefined, caseSensitive?: boolean): string;
-type LexicalCategory = 'comment' | 'string' | 'code';
-/** Best-effort lexical category of the token's occurrence on a single line.
- * Deterministic and conservative — used only in the regex fallback path when
- * the engine's grammar-accurate AST kind is unavailable. */
-export declare function lexicalCategoryOf(line: string, token: string | undefined, profileId: RankingProfileId, caseSensitive?: boolean): LexicalCategory;
-/** Whether byte index `idx` falls inside a quoted region of the line. */
-export declare function isIndexInsideString(line: string, idx: number): boolean;
-export {};

package/dist/tools/local_ripgrep/rankingProfile.d.ts

@@ -1,5 +1,5 @@
 /**
- * Tier 1 — within-source language-aware ranking for localSearchCode.
+ * Tier 1 — within-source language-aware ranking for local text search.
  *
  * Replaces "more matches first, then path" with a stable, inspectable relevance
  * score. See `.octocode/RANKING-ARCHITECTURE.md`.
@@ -22,8 +22,8 @@
  *    tables, path-role regexes, `selectProfile`/`classifyPathRole`).
  *  - `rankingProfile/rankingScoring.ts`: the scoring engine (`bestLineScore`,
  *    `pathAffinityScore`, `candidateTermRarityScore`, `scoreFileWithRarity`).
- *  - `rankingProfile/rankingResults.ts`: `rankFiles`/`RankResult` plus the
- *    lexical helpers (`lexicalCategoryOf`, `isIndexInsideString`, etc.).
+ *  - `rankingProfile/rankingResults.ts`: `rankFiles`/`RankResult` orchestration.
+ *  - `rankingProfile/rankingLexical.ts`: shared pure lexical helpers.
  * Re-exported here so no other module needs to change its import path.
  */
 export type { RankingProfileId, RankSort, PathRole, RankingProfile, } from './rankingProfile/rankingProfiles.js';
@@ -31,4 +31,5 @@ export { RANKING_PROFILE_IDS, RANK_WEIGHTS, RANK_CANDIDATE_CAP, COMMENT_LINE, HE
 export type { RankContext, FileScore, } from './rankingProfile/rankingScoring.js';
 export { buildCandidateTermRarity, scoreFileWithRarity, scoreFile, } from './rankingProfile/rankingScoring.js';
 export type { RankResult } from './rankingProfile/rankingResults.js';
-export { rankFiles, matchesAny, escapeRegex, isPlainIdentifierKeyword, matchedLineOf, lexicalCategoryOf, isIndexInsideString, } from './rankingProfile/rankingResults.js';
+export { rankFiles } from './rankingProfile/rankingResults.js';
+export { matchesAny, escapeRegex, isPlainIdentifierKeyword, matchedLineOf, lexicalCategoryOf, isIndexInsideString, } from './rankingProfile/rankingLexical.js';

package/dist/tools/local_ripgrep/ripgrepResultBuilder/searchNext.d.ts

@@ -1,7 +1,7 @@
 import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
 import type { RipgrepQuery } from '../scheme.js';
 import type { LocalSearchEngine } from './buildResult.js';
-type NextToolName = 'localGetFileContent' | 'lspGetSemantics' | 'localSearchCode';
+type NextToolName = 'localGetFileContent' | 'lspGetSemantics' | 'local.text';
 type NextConfidence = 'exact' | 'low';
 type SearchNextCall = {
     tool: NextToolName;
@@ -15,6 +15,8 @@ export type SearchNextMap = {
     lspReferences?: SearchNextCall;
     nextPage?: SearchNextCall;
     nextMatchPage?: SearchNextCall;
+    expandScan?: SearchNextCall;
+    expandCaptures?: SearchNextCall;
 };
 type FlowMatch = {
     line?: number;
@@ -24,6 +26,7 @@ type FlowMatch = {
     metavarRanges?: Record<string, Array<{
         line: number;
     }>>;
+    capturesTruncated?: boolean;
 };
 export declare function buildSearchNextMap(files: LocalSearchCodeFile[], query: RipgrepQuery, searchEngine: LocalSearchEngine, options: {
     isFileListMode: boolean;

package/dist/tools/local_ripgrep/scheme.d.ts

@@ -5,10 +5,10 @@ export declare const LocalRipgrepQuerySchema: z.ZodObject<{
     searchText: z.ZodOptional<z.ZodString>;
     path: z.ZodString;
     mode: z.ZodDefault<z.ZodEnum<{
+        structural: "structural";
         paginated: "paginated";
         discovery: "discovery";
         detailed: "detailed";
-        structural: "structural";
     }>>;
     pattern: z.ZodOptional<z.ZodString>;
     rule: z.ZodOptional<z.ZodString>;
@@ -33,6 +33,7 @@ export declare const LocalRipgrepQuerySchema: z.ZodObject<{
     matchContentLength: z.ZodDefault<z.ZodNumber>;
     maxMatchesPerFile: z.ZodOptional<z.ZodNumber>;
     maxFiles: z.ZodOptional<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
     multiline: z.ZodDefault<z.ZodEnum<{
         off: "off";
         on: "on";
@@ -48,8 +49,8 @@ export declare const LocalRipgrepQuerySchema: z.ZodObject<{
     }>>;
     sortReverse: z.ZodOptional<z.ZodBoolean>;
     rankingProfile: z.ZodDefault<z.ZodEnum<{
-        auto: "auto";
         typescript: "typescript";
+        auto: "auto";
         javascript: "javascript";
         rust: "rust";
         python: "python";
@@ -72,17 +73,15 @@ export declare const LocalRipgrepQuerySchema: z.ZodObject<{
         matchOnly: "matchOnly";
     }>>;
     unique: z.ZodDefault<z.ZodEnum<{
+        count: "count";
         list: "list";
         off: "off";
-        count: "count";
     }>>;
     matchWindow: z.ZodOptional<z.ZodNumber>;
     matchPage: z.ZodOptional<z.ZodNumber>;
     itemsPerPage: z.ZodOptional<z.ZodNumber>;
     page: z.ZodDefault<z.ZodNumber>;
-    id: z.ZodOptional<z.ZodString>;
-    mainResearchGoal: z.ZodOptional<z.ZodString>;
-    researchGoal: z.ZodOptional<z.ZodString>;
+    goal: z.ZodOptional<z.ZodString>;
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type RipgrepQuery = z.infer<typeof LocalRipgrepQuerySchema>;
@@ -90,7 +89,7 @@ export declare const LocalRipgrepBulkQuerySchema: z.ZodObject<{
     responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export interface LocalSearchMatch {
     line: number;
     endLine?: number;
@@ -145,5 +144,8 @@ export interface LocalSearchCodeData {
     };
     pagination?: LocalItemPagination;
     next?: Record<string, ToolContinuation>;
+    terminalLimit?: boolean;
+    truncated?: boolean;
+    partialReasons?: Array<'maxFiles'>;
 }
 export type LocalSearchCodeOutput = BulkToolOutput<LocalSearchCodeData>;

package/dist/tools/local_ripgrep/structuralSearch.d.ts

@@ -2,7 +2,7 @@ import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-
 import type { RipgrepQuery } from './scheme.js';
 /**
  * mode:"structural" execution path. Path validation and result shaping stay in
- * TypeScript with the rest of localSearchCode; filesystem traversal, file reads,
+ * TypeScript with the rest of local text search; filesystem traversal, file reads,
  * pre-filtering, parsing, and Octocode AST matching run in native Rust.
  */
 export declare function searchContentStructural(query: RipgrepQuery): Promise<LocalSearchCodeToolResult>;

package/dist/tools/local_search/execution.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from '@modelcontextprotocol/server';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+import { type LocalSearchQuery } from './scheme.js';
+export { LOCAL_SEARCH_TOOL_NAME } from '../toolNames.js';
+export declare function executeLocalSearch(args: ToolExecutionArgs<LocalSearchQuery>): Promise<CallToolResult>;