@octocodeai/octocode-tools-core 16.6.3 → 17.0.2

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

@@ -44,9 +44,9 @@ export declare const LocalGetFileContentOutputSchema: z.ZodObject<{
                 standard: "standard";
                 symbols: "symbols";
             }>>;
-            isSkeleton: z.ZodOptional<z.ZodBoolean>;
             totalLines: z.ZodOptional<z.ZodNumber>;
             sourceChars: z.ZodOptional<z.ZodNumber>;
+            sourceBytes: z.ZodOptional<z.ZodNumber>;
             startLine: z.ZodOptional<z.ZodNumber>;
             endLine: z.ZodOptional<z.ZodNumber>;
             isPartial: z.ZodOptional<z.ZodBoolean>;
@@ -66,6 +66,7 @@ export declare const LocalGetFileContentOutputSchema: z.ZodObject<{
                     semantic: "semantic";
                     "char-limit": "char-limit";
                 }>>;
+                nextBlockChar: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>, z.ZodObject<{
                 currentPage: z.ZodNumber;
                 totalPages: z.ZodNumber;
@@ -73,7 +74,30 @@ export declare const LocalGetFileContentOutputSchema: z.ZodObject<{
                 nextPage: z.ZodOptional<z.ZodNumber>;
                 pageSize: z.ZodOptional<z.ZodNumber>;
                 totalItems: z.ZodOptional<z.ZodNumber>;
+                perPage: z.ZodOptional<z.ZodNumber>;
+                totalFound: z.ZodOptional<z.ZodNumber>;
+                returned: z.ZodOptional<z.ZodNumber>;
+                totalMatches: z.ZodOptional<z.ZodNumber>;
+                reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
+                reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
+                totalMatchesKind: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    reported: "reported";
+                    lowerBound: "lowerBound";
+                }>>;
+                totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
+                totalResults: z.ZodOptional<z.ZodNumber>;
+                itemsPerPage: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>]>>;
+            next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                tool: z.ZodString;
+                query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                why: z.ZodOptional<z.ZodString>;
+                confidence: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    heuristic: "heuristic";
+                }>>;
+            }, z.core.$strip>>>;
             modified: z.ZodOptional<z.ZodString>;
             lastModified: z.ZodOptional<z.ZodString>;
             lastModifiedBy: z.ZodOptional<z.ZodString>;

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

@@ -15,6 +15,7 @@ export declare const LocalFindFilesOutputSchema: z.ZodObject<{
             error: "error";
         }>>;
         data: z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
             files: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 name: z.ZodOptional<z.ZodString>;
                 path: z.ZodOptional<z.ZodString>;
@@ -26,6 +27,7 @@ export declare const LocalFindFilesOutputSchema: z.ZodObject<{
                     symlink: "symlink";
                 }>>;
                 size: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+                sizeFormatted: z.ZodOptional<z.ZodString>;
                 modified: z.ZodOptional<z.ZodString>;
                 accessed: z.ZodOptional<z.ZodString>;
                 created: z.ZodOptional<z.ZodString>;
@@ -39,7 +41,37 @@ export declare const LocalFindFilesOutputSchema: z.ZodObject<{
                 nextPage: z.ZodOptional<z.ZodNumber>;
                 pageSize: z.ZodOptional<z.ZodNumber>;
                 totalItems: z.ZodOptional<z.ZodNumber>;
+                perPage: z.ZodOptional<z.ZodNumber>;
+                totalFound: z.ZodOptional<z.ZodNumber>;
+                returned: z.ZodOptional<z.ZodNumber>;
+                reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
+                reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
+                totalMatchesKind: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    reported: "reported";
+                    lowerBound: "lowerBound";
+                }>>;
+                totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
+                totalResults: z.ZodOptional<z.ZodNumber>;
+                itemsPerPage: z.ZodOptional<z.ZodNumber>;
+                filesPerPage: z.ZodOptional<z.ZodNumber>;
+                entriesPerPage: z.ZodOptional<z.ZodNumber>;
+                matchesPerPage: z.ZodOptional<z.ZodNumber>;
+                totalFiles: z.ZodOptional<z.ZodNumber>;
+                totalEntries: z.ZodOptional<z.ZodNumber>;
+                totalMatches: z.ZodOptional<z.ZodNumber>;
+                totalFilesFound: z.ZodOptional<z.ZodNumber>;
+                nextMatchPage: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
+            next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                tool: z.ZodString;
+                query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                why: z.ZodOptional<z.ZodString>;
+                confidence: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    heuristic: "heuristic";
+                }>>;
+            }, z.core.$strip>>>;
             warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>;
     }, z.core.$strip>>;

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

@@ -0,0 +1,70 @@
+/**
+ * Ranking profile data/config — language profile tables, path-role
+ * classification, and the tunable weight policy. See
+ * `.octocode/RANKING-ARCHITECTURE.md` and the module doc in
+ * `../rankingProfile.ts` (the public barrel) for the full contract.
+ *
+ * This module owns *what* a profile is and *where* a path lives (its role);
+ * `rankingScoring.ts` owns *how much* each signal is worth in a score.
+ */
+export type RankingProfileId = 'typescript' | 'javascript' | 'rust' | 'python' | 'go' | 'java' | 'scala' | 'markdown' | 'json' | 'yaml' | 'generic';
+/** TS-level result orderings. `relevance` is the language-aware scorer. */
+export type RankSort = 'relevance' | 'matchCount' | 'path' | 'created' | 'modified' | 'accessed';
+export declare const RANKING_PROFILE_IDS: readonly ["typescript", "javascript", "rust", "python", "go", "java", "scala", "markdown", "json", "yaml", "generic"];
+export type PathRole = 'source' | 'test' | 'docs' | 'config' | 'generated' | 'fixture' | 'unknown';
+/**
+ * All ranking weights in one place. Tuning happens here and in the golden
+ * fixtures, never scattered across the scorer. Values are deliberately
+ * integer-ish and additive so a score can be read back from its reasons.
+ */
+export declare const RANK_WEIGHTS: {
+    readonly exactWholeWord: 6;
+    readonly exactCaseInsensitive: 3;
+    readonly substring: 1;
+    readonly declarationLine: 8;
+    readonly exportLine: 4;
+    readonly importLine: 3;
+    readonly configKeyLine: 4;
+    readonly headingLine: 4;
+    readonly commentOrStringPenalty: -2;
+    readonly pathUnderQuery: 4;
+    readonly pathSegmentToken: 3;
+    readonly extMatchesLangType: 2;
+    readonly sourceDir: 1.5;
+    readonly lowSignalPathPenalty: -5;
+    readonly rareQueryTokenScale: 2;
+    readonly rareQueryTokenCap: 3;
+    readonly matchCountScale: 1.5;
+    readonly matchCountCap: 6;
+};
+/**
+ * Bound on how many files get full scoring before pagination. The engine text
+ * path returns the entire result set unbounded (no global file/match cap), so
+ * for broad terms in a large monorepo we must not score O(total files). When
+ * the cap bites we deterministically prefilter (matchCount desc, path asc)
+ * before scoring, and the builder surfaces a `truncated`-style note.
+ */
+export declare const RANK_CANDIDATE_CAP = 2000;
+export interface RankingProfile {
+    id: RankingProfileId;
+    extensions: readonly string[];
+    /** Lines that declare/define a symbol named like the query — highest signal. */
+    declaration: readonly RegExp[];
+    /** Exported/public surface. */
+    export: readonly RegExp[];
+    /** Import/use lines. */
+    import: readonly RegExp[];
+}
+export declare const COMMENT_LINE: RegExp;
+export declare const HEADING_LINE: RegExp;
+export declare const LOW_SIGNAL_PATH: RegExp;
+export declare const EXT_RE: RegExp;
+export declare function fileExtension(path: string): string;
+/** Deterministic profile selection from query langType then file extension. */
+export declare function selectProfile(path: string, langType?: string, override?: RankingProfileId | 'auto'): RankingProfile;
+export declare function classifyPathRole(path: string): PathRole;
+/** True when the query path explicitly targets a low-signal area, so the
+ * scorer should not penalize generated/test/docs/fixture roles. Uses anchored
+ * path-segment matching (not substring) so `latest/`, `contest/`, `manifest/`
+ * do NOT count as low-signal. */
+export declare function isLowSignalQueryPath(path: string | undefined): boolean;

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

@@ -0,0 +1,47 @@
+/**
+ * Ranking results — the top-level `rankFiles` entry point plus the small
+ * lexical helpers (comment/string detection, token indexing) that classify a
+ * matched line before the scorer in `rankingScoring.ts` weighs it.
+ *
+ * `rankFiles` composes the scoring engine (`scoreFileWithRarity`,
+ * `buildCandidateTermRarity`) over the whole candidate set: it applies the
+ * candidate cap, builds candidate-local term rarity once, scores every file,
+ * and produces a total, deterministic order. See the module doc in
+ * `../rankingProfile.ts` for the full contract.
+ */
+import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
+import type { RankingProfileId, RankSort } from './rankingProfiles.js';
+import type { FileScore, RankContext } from './rankingScoring.js';
+export interface RankResult {
+    files: LocalSearchCodeFile[];
+    /** Per-path debug info, only populated when debug is requested. */
+    debug?: Map<string, FileScore>;
+    /** Number of files dropped by the candidate cap before scoring (0 if none). */
+    cappedCandidates: number;
+}
+/**
+ * Rank files by the requested sort mode. `relevance` is the language-aware
+ * scorer (default); `matchCount` and `path` are deterministic escape hatches;
+ * filesystem sorts (created/modified/accessed) preserve the engine's order.
+ */
+export declare function rankFiles(files: LocalSearchCodeFile[], sort: RankSort, ctx: RankContext, opts?: {
+    debug?: boolean;
+    candidateCap?: number;
+}): 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/rankingScoring.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Ranking scoring engine — turns a candidate file's matches, path, and the
+ * query context into an additive, explainable `FileScore`. Every function
+ * here appends to a shared `reasons: string[]` accumulator; call order is
+ * significant because scores are additive and reasons are appended in the
+ * order they are computed. Do not reorder the calls inside
+ * `scoreFileWithRarity` or `bestLineScore`.
+ *
+ * See the module doc in `../rankingProfile.ts` for the full contract.
+ */
+import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
+import { type PathRole, type RankingProfileId } from './rankingProfiles.js';
+export interface RankContext {
+    /** Validated, sanitized search base path (query.path). */
+    queryPath?: string;
+    /** The literal keyword/pattern, used for whole-word / token / path checks. */
+    keyword?: string;
+    langType?: string;
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+    /** Profile override from query.rankingProfile. */
+    profileOverride?: RankingProfileId | 'auto';
+    /** True when the user explicitly searched into a low-signal/test/docs area. */
+    explicitLowSignal?: boolean;
+}
+export interface FileScore {
+    score: number;
+    profile: RankingProfileId;
+    pathRole: PathRole;
+    reasons: string[];
+}
+type CandidateTermRarity = {
+    candidateCount: number;
+    fileTokens: ReadonlyMap<string, readonly string[]>;
+    documentFrequency: ReadonlyMap<string, number>;
+};
+export declare function buildCandidateTermRarity(files: LocalSearchCodeFile[], ctx: RankContext): CandidateTermRarity | undefined;
+export declare function scoreFileWithRarity(file: LocalSearchCodeFile, ctx: RankContext, rarity?: CandidateTermRarity): FileScore;
+/** Score one file. Pure and deterministic. */
+export declare function scoreFile(file: LocalSearchCodeFile, ctx: RankContext): FileScore;
+export {};

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

@@ -15,99 +15,20 @@
  * Not rigid: profiles are declarative tables, all weights live in one policy
  * object, new languages register by adding a profile. AST/LSP signals (Phase
  * 2/3) layer on top without changing this contract.
+ *
+ * This file is a thin barrel: the implementation lives in `rankingProfile/`,
+ * split by concern —
+ *  - `rankingProfile/rankingProfiles.ts`: profile data/config (language
+ *    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.).
+ * Re-exported here so no other module needs to change its import path.
  */
-import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
-export type RankingProfileId = 'typescript' | 'javascript' | 'rust' | 'python' | 'go' | 'java' | 'scala' | 'markdown' | 'json' | 'yaml' | 'generic';
-/** TS-level result orderings. `relevance` is the language-aware scorer. */
-export type RankSort = 'relevance' | 'matchCount' | 'path' | 'created' | 'modified' | 'accessed';
-export declare const RANKING_PROFILE_IDS: readonly ["typescript", "javascript", "rust", "python", "go", "java", "scala", "markdown", "json", "yaml", "generic"];
-type PathRole = 'source' | 'test' | 'docs' | 'config' | 'generated' | 'fixture' | 'unknown';
-/**
- * All ranking weights in one place. Tuning happens here and in the golden
- * fixtures, never scattered across the scorer. Values are deliberately
- * integer-ish and additive so a score can be read back from its reasons.
- */
-export declare const RANK_WEIGHTS: {
-    readonly exactWholeWord: 6;
-    readonly exactCaseInsensitive: 3;
-    readonly substring: 1;
-    readonly declarationLine: 8;
-    readonly exportLine: 4;
-    readonly importLine: 3;
-    readonly configKeyLine: 4;
-    readonly headingLine: 4;
-    readonly commentOrStringPenalty: -2;
-    readonly pathUnderQuery: 4;
-    readonly pathSegmentToken: 3;
-    readonly extMatchesLangType: 2;
-    readonly sourceDir: 1.5;
-    readonly lowSignalPathPenalty: -5;
-    readonly rareQueryTokenScale: 2;
-    readonly rareQueryTokenCap: 3;
-    readonly matchCountScale: 1.5;
-    readonly matchCountCap: 6;
-};
-/**
- * Bound on how many files get full scoring before pagination. The engine text
- * path returns the entire result set unbounded (no global file/match cap), so
- * for broad terms in a large monorepo we must not score O(total files). When
- * the cap bites we deterministically prefilter (matchCount desc, path asc)
- * before scoring, and the builder surfaces a `truncated`-style note.
- */
-export declare const RANK_CANDIDATE_CAP = 2000;
-interface RankingProfile {
-    id: RankingProfileId;
-    extensions: readonly string[];
-    /** Lines that declare/define a symbol named like the query — highest signal. */
-    declaration: readonly RegExp[];
-    /** Exported/public surface. */
-    export: readonly RegExp[];
-    /** Import/use lines. */
-    import: readonly RegExp[];
-}
-/** Deterministic profile selection from query langType then file extension. */
-export declare function selectProfile(path: string, langType?: string, override?: RankingProfileId | 'auto'): RankingProfile;
-export declare function classifyPathRole(path: string): PathRole;
-export interface RankContext {
-    /** Validated, sanitized search base path (query.path). */
-    queryPath?: string;
-    /** The literal keyword/pattern, used for whole-word / token / path checks. */
-    keyword?: string;
-    langType?: string;
-    caseSensitive?: boolean;
-    wholeWord?: boolean;
-    /** Profile override from query.rankingProfile. */
-    profileOverride?: RankingProfileId | 'auto';
-    /** True when the user explicitly searched into a low-signal/test/docs area. */
-    explicitLowSignal?: boolean;
-}
-export interface FileScore {
-    score: number;
-    profile: RankingProfileId;
-    pathRole: PathRole;
-    reasons: string[];
-}
-/** Score one file. Pure and deterministic. */
-export declare function scoreFile(file: LocalSearchCodeFile, ctx: RankContext): FileScore;
-export interface RankResult {
-    files: LocalSearchCodeFile[];
-    /** Per-path debug info, only populated when debug is requested. */
-    debug?: Map<string, FileScore>;
-    /** Number of files dropped by the candidate cap before scoring (0 if none). */
-    cappedCandidates: number;
-}
-/**
- * Rank files by the requested sort mode. `relevance` is the language-aware
- * scorer (default); `matchCount` and `path` are deterministic escape hatches;
- * filesystem sorts (created/modified/accessed) preserve the engine's order.
- */
-export declare function rankFiles(files: LocalSearchCodeFile[], sort: RankSort, ctx: RankContext, opts?: {
-    debug?: boolean;
-    candidateCap?: number;
-}): RankResult;
-/** True when the query path explicitly targets a low-signal area, so the
- * scorer should not penalize generated/test/docs/fixture roles. Uses anchored
- * path-segment matching (not substring) so `latest/`, `contest/`, `manifest/`
- * do NOT count as low-signal. */
-export declare function isLowSignalQueryPath(path: string | undefined): boolean;
-export {};
+export type { RankingProfileId, RankSort, PathRole, RankingProfile, } from './rankingProfile/rankingProfiles.js';
+export { RANKING_PROFILE_IDS, RANK_WEIGHTS, RANK_CANDIDATE_CAP, COMMENT_LINE, HEADING_LINE, LOW_SIGNAL_PATH, EXT_RE, fileExtension, selectProfile, classifyPathRole, isLowSignalQueryPath, } from './rankingProfile/rankingProfiles.js';
+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';

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

@@ -0,0 +1,10 @@
+import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
+import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-types';
+import type { SearchStats } from '../../../utils/core/types.js';
+import type { RipgrepQuery } from '../scheme.js';
+export type LocalSearchEngine = 'rg' | 'structural';
+export declare function buildSearchResult(parsedFiles: LocalSearchCodeFile[], configuredQuery: RipgrepQuery, searchEngine: LocalSearchEngine, warnings: string[], stats?: SearchStats): Promise<LocalSearchCodeToolResult>;
+export declare function finalizeRipgrepResult(result: LocalSearchCodeToolResult, _query: RipgrepQuery, _totals: {
+    totalMatches: number;
+    totalFiles: number;
+}): LocalSearchCodeToolResult;

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

@@ -0,0 +1,46 @@
+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 NextConfidence = 'exact' | 'heuristic';
+type SearchNextCall = {
+    tool: NextToolName;
+    query: Record<string, unknown>;
+    why: string;
+    confidence?: NextConfidence;
+};
+export type SearchNextMap = {
+    fetch?: SearchNextCall;
+    lspDefinition?: SearchNextCall;
+    lspReferences?: SearchNextCall;
+    nextPage?: SearchNextCall;
+    nextMatchPage?: SearchNextCall;
+};
+type FlowMatch = {
+    line?: number;
+    endLine?: number;
+    value?: string;
+    metavars?: Record<string, string[]>;
+    metavarRanges?: Record<string, Array<{
+        line: number;
+    }>>;
+};
+export declare function buildSearchNextMap(files: LocalSearchCodeFile[], query: RipgrepQuery, searchEngine: LocalSearchEngine, options: {
+    isFileListMode: boolean;
+    currentPage: number;
+    totalFilePages: number;
+    matchPage: number;
+    matchesPerPage: number;
+    hasFileWithMoreMatches: boolean;
+}): SearchNextMap;
+export type InferredLspSymbol = {
+    symbol: string;
+    /**
+     * Precise capture line from `metavarRanges` (structural search only).
+     * Undefined when the search engine doesn't carry per-capture ranges — the
+     * caller falls back to the match's own start line.
+     */
+    line?: number;
+};
+export declare function inferLspSymbolName(match: FlowMatch | undefined, query: RipgrepQuery, searchEngine: LocalSearchEngine): InferredLspSymbol | undefined;
+export {};

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

@@ -1,18 +1,2 @@
-import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
-import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-types';
-import type { SearchStats } from '../../utils/core/types.js';
-import type { RipgrepQuery } from './scheme.js';
-export type LocalSearchEngine = 'rg' | 'structural';
-type FlowMatch = {
-    line?: number;
-    endLine?: number;
-    value?: string;
-    metavars?: Record<string, string[]>;
-};
-export declare function buildSearchResult(parsedFiles: LocalSearchCodeFile[], configuredQuery: RipgrepQuery, searchEngine: LocalSearchEngine, warnings: string[], stats?: SearchStats): Promise<LocalSearchCodeToolResult>;
-export declare function finalizeRipgrepResult(result: LocalSearchCodeToolResult, _query: RipgrepQuery, _totals: {
-    totalMatches: number;
-    totalFiles: number;
-}): LocalSearchCodeToolResult;
-export declare function inferLspSymbolName(match: FlowMatch | undefined, query: RipgrepQuery, searchEngine: LocalSearchEngine): string | undefined;
-export {};
+export * from './ripgrepResultBuilder/buildResult.js';
+export * from './ripgrepResultBuilder/searchNext.js';

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

@@ -93,13 +93,29 @@ export declare const LocalSearchCodeOutputSchema: z.ZodObject<{
                     endLine: z.ZodOptional<z.ZodNumber>;
                     value: z.ZodOptional<z.ZodString>;
                     column: z.ZodOptional<z.ZodNumber>;
+                    endColumn: z.ZodOptional<z.ZodNumber>;
                     count: z.ZodOptional<z.ZodNumber>;
+                    kind: z.ZodOptional<z.ZodString>;
+                    scoreHint: z.ZodOptional<z.ZodNumber>;
                     metavars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+                    metavarRanges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                        text: z.ZodString;
+                        line: z.ZodNumber;
+                        column: z.ZodNumber;
+                        endLine: z.ZodNumber;
+                        endColumn: z.ZodNumber;
+                    }, z.core.$strip>>>>;
                 }, z.core.$strip>>>;
                 totalOccurrences: z.ZodOptional<z.ZodNumber>;
                 totalMatchedLines: z.ZodOptional<z.ZodNumber>;
                 totalMatchRows: z.ZodOptional<z.ZodNumber>;
                 returnedMatchRows: z.ZodOptional<z.ZodNumber>;
+                ranking: z.ZodOptional<z.ZodObject<{
+                    score: z.ZodNumber;
+                    profile: z.ZodOptional<z.ZodString>;
+                    pathRole: z.ZodOptional<z.ZodString>;
+                    reasons: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
                 matchPagination: z.ZodOptional<z.ZodObject<{
                     currentPage: z.ZodNumber;
                     totalPages: z.ZodNumber;
@@ -107,6 +123,56 @@ export declare const LocalSearchCodeOutputSchema: z.ZodObject<{
                     nextPage: z.ZodOptional<z.ZodNumber>;
                     pageSize: z.ZodOptional<z.ZodNumber>;
                     totalItems: z.ZodOptional<z.ZodNumber>;
+                    perPage: z.ZodOptional<z.ZodNumber>;
+                    totalFound: z.ZodOptional<z.ZodNumber>;
+                    returned: z.ZodOptional<z.ZodNumber>;
+                    reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
+                    reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
+                    totalMatchesKind: z.ZodOptional<z.ZodEnum<{
+                        exact: "exact";
+                        reported: "reported";
+                        lowerBound: "lowerBound";
+                    }>>;
+                    totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
+                    totalResults: z.ZodOptional<z.ZodNumber>;
+                    itemsPerPage: z.ZodOptional<z.ZodNumber>;
+                    filesPerPage: z.ZodOptional<z.ZodNumber>;
+                    entriesPerPage: z.ZodOptional<z.ZodNumber>;
+                    matchesPerPage: z.ZodOptional<z.ZodNumber>;
+                    totalFiles: z.ZodOptional<z.ZodNumber>;
+                    totalEntries: z.ZodOptional<z.ZodNumber>;
+                    totalMatches: z.ZodOptional<z.ZodNumber>;
+                    totalFilesFound: z.ZodOptional<z.ZodNumber>;
+                    nextMatchPage: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                pagination: z.ZodOptional<z.ZodObject<{
+                    currentPage: z.ZodNumber;
+                    totalPages: z.ZodNumber;
+                    hasMore: z.ZodBoolean;
+                    nextPage: z.ZodOptional<z.ZodNumber>;
+                    pageSize: z.ZodOptional<z.ZodNumber>;
+                    totalItems: z.ZodOptional<z.ZodNumber>;
+                    perPage: z.ZodOptional<z.ZodNumber>;
+                    totalFound: z.ZodOptional<z.ZodNumber>;
+                    returned: z.ZodOptional<z.ZodNumber>;
+                    reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
+                    reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
+                    totalMatchesKind: z.ZodOptional<z.ZodEnum<{
+                        exact: "exact";
+                        reported: "reported";
+                        lowerBound: "lowerBound";
+                    }>>;
+                    totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
+                    totalResults: z.ZodOptional<z.ZodNumber>;
+                    itemsPerPage: z.ZodOptional<z.ZodNumber>;
+                    filesPerPage: z.ZodOptional<z.ZodNumber>;
+                    entriesPerPage: z.ZodOptional<z.ZodNumber>;
+                    matchesPerPage: z.ZodOptional<z.ZodNumber>;
+                    totalFiles: z.ZodOptional<z.ZodNumber>;
+                    totalEntries: z.ZodOptional<z.ZodNumber>;
+                    totalMatches: z.ZodOptional<z.ZodNumber>;
+                    totalFilesFound: z.ZodOptional<z.ZodNumber>;
+                    nextMatchPage: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>>;
                 next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                     tool: z.ZodString;
@@ -120,6 +186,14 @@ export declare const LocalSearchCodeOutputSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             summary: z.ZodOptional<z.ZodString>;
             searchEngine: z.ZodOptional<z.ZodString>;
+            stats: z.ZodOptional<z.ZodObject<{
+                totalOccurrences: z.ZodOptional<z.ZodNumber>;
+                matchedLines: z.ZodOptional<z.ZodNumber>;
+                filesMatched: z.ZodOptional<z.ZodNumber>;
+                filesSearched: z.ZodOptional<z.ZodNumber>;
+                bytesSearched: z.ZodOptional<z.ZodNumber>;
+                searchTime: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
             pagination: z.ZodOptional<z.ZodObject<{
                 currentPage: z.ZodNumber;
                 totalPages: z.ZodNumber;
@@ -127,6 +201,27 @@ export declare const LocalSearchCodeOutputSchema: z.ZodObject<{
                 nextPage: z.ZodOptional<z.ZodNumber>;
                 pageSize: z.ZodOptional<z.ZodNumber>;
                 totalItems: z.ZodOptional<z.ZodNumber>;
+                perPage: z.ZodOptional<z.ZodNumber>;
+                totalFound: z.ZodOptional<z.ZodNumber>;
+                returned: z.ZodOptional<z.ZodNumber>;
+                reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
+                reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
+                totalMatchesKind: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    reported: "reported";
+                    lowerBound: "lowerBound";
+                }>>;
+                totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
+                totalResults: z.ZodOptional<z.ZodNumber>;
+                itemsPerPage: z.ZodOptional<z.ZodNumber>;
+                filesPerPage: z.ZodOptional<z.ZodNumber>;
+                entriesPerPage: z.ZodOptional<z.ZodNumber>;
+                matchesPerPage: z.ZodOptional<z.ZodNumber>;
+                totalFiles: z.ZodOptional<z.ZodNumber>;
+                totalEntries: z.ZodOptional<z.ZodNumber>;
+                totalMatches: z.ZodOptional<z.ZodNumber>;
+                totalFilesFound: z.ZodOptional<z.ZodNumber>;
+                nextMatchPage: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
             next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 tool: z.ZodString;

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

@@ -52,6 +52,7 @@ export declare const LocalViewStructureOutputSchema: z.ZodObject<{
                 path: z.ZodOptional<z.ZodString>;
                 depth: z.ZodOptional<z.ZodNumber>;
                 size: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+                sizeBytes: z.ZodOptional<z.ZodNumber>;
                 modified: z.ZodOptional<z.ZodString>;
                 permissions: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>>;
@@ -66,7 +67,37 @@ export declare const LocalViewStructureOutputSchema: z.ZodObject<{
                 nextPage: z.ZodOptional<z.ZodNumber>;
                 pageSize: z.ZodOptional<z.ZodNumber>;
                 totalItems: z.ZodOptional<z.ZodNumber>;
+                perPage: z.ZodOptional<z.ZodNumber>;
+                totalFound: z.ZodOptional<z.ZodNumber>;
+                returned: z.ZodOptional<z.ZodNumber>;
+                reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
+                reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
+                totalMatchesKind: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    reported: "reported";
+                    lowerBound: "lowerBound";
+                }>>;
+                totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
+                totalResults: z.ZodOptional<z.ZodNumber>;
+                itemsPerPage: z.ZodOptional<z.ZodNumber>;
+                filesPerPage: z.ZodOptional<z.ZodNumber>;
+                entriesPerPage: z.ZodOptional<z.ZodNumber>;
+                matchesPerPage: z.ZodOptional<z.ZodNumber>;
+                totalFiles: z.ZodOptional<z.ZodNumber>;
+                totalEntries: z.ZodOptional<z.ZodNumber>;
+                totalMatches: z.ZodOptional<z.ZodNumber>;
+                totalFilesFound: z.ZodOptional<z.ZodNumber>;
+                nextMatchPage: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
+            next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                tool: z.ZodString;
+                query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                why: z.ZodOptional<z.ZodString>;
+                confidence: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    heuristic: "heuristic";
+                }>>;
+            }, z.core.$strip>>>;
             warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>;
     }, z.core.$strip>>;