@octocodeai/octocode-tools-core 16.2.0 → 16.5.1

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

@@ -130,8 +130,8 @@ export declare const GitHubPullRequestSearchQueryLocalSchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const GitHubPullRequestSearchBulkQueryLocalSchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    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>;
 export declare const GitHubSearchPullRequestsOutputLocalSchema: z.ZodObject<{
@@ -160,6 +160,8 @@ export declare const GitHubSearchPullRequestsOutputLocalSchema: z.ZodObject<{
             currentPage: z.ZodNumber;
             totalPages: z.ZodNumber;
             hasMore: z.ZodBoolean;
+            nextPage: z.ZodOptional<z.ZodNumber>;
+            nextMatchPage: z.ZodOptional<z.ZodNumber>;
             perPage: z.ZodOptional<z.ZodNumber>;
             totalMatches: z.ZodOptional<z.ZodNumber>;
             totalFiles: z.ZodOptional<z.ZodNumber>;
@@ -189,6 +191,8 @@ export declare const GitHubSearchPullRequestsOutputLocalSchema: z.ZodObject<{
         currentPage: z.ZodNumber;
         totalPages: z.ZodNumber;
         hasMore: z.ZodBoolean;
+        nextPage: z.ZodOptional<z.ZodNumber>;
+        nextMatchPage: z.ZodOptional<z.ZodNumber>;
         perPage: z.ZodOptional<z.ZodNumber>;
         totalMatches: z.ZodOptional<z.ZodNumber>;
         totalFiles: z.ZodOptional<z.ZodNumber>;

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

@@ -37,8 +37,8 @@ export declare const GitHubReposSearchSingleQueryLocalSchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const GitHubReposSearchBulkQueryLocalSchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    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>;
 export declare const GitHubSearchRepositoriesOutputLocalSchema: z.ZodObject<{
@@ -78,13 +78,14 @@ export declare const GitHubSearchRepositoriesOutputLocalSchema: z.ZodObject<{
                     lowerBound: "lowerBound";
                 }>>;
                 totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
+                nextPage: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$loose>>;
     }, z.core.$loose>>>;
-    readonly hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    readonly base: z.ZodOptional<z.ZodString>;
-    readonly shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
-    readonly responsePagination: z.ZodOptional<z.ZodObject<{
+    hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    base: z.ZodOptional<z.ZodString>;
+    shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    responsePagination: z.ZodOptional<z.ZodObject<{
         currentPage: z.ZodNumber;
         totalPages: z.ZodNumber;
         hasMore: z.ZodBoolean;

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

@@ -8,13 +8,4 @@ type PartialRepoStructureQuery = WithOptionalMeta<GitHubViewRepoStructureQuery>;
 import type { ToolExecutionArgs } from '../../types/execution.js';
 export declare function filterStructure(structure: Record<string, GitHubRepoStructureDirectoryEntry>): Record<string, GitHubRepoStructureDirectoryEntry>;
 export declare function exploreMultipleRepositoryStructures(args: ToolExecutionArgs<PartialRepoStructureQuery>): Promise<CallToolResult>;
-export declare function buildRepoStructureOutput(input: {
-    data: Record<string, unknown>;
-    entryCount: number;
-    wasTruncated: boolean;
-    extraHints: string[];
-}, _query: PartialRepoStructureQuery): {
-    data: Record<string, unknown>;
-    extraHints: string[];
-};
 export {};

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

@@ -13,8 +13,8 @@ export declare const GitHubViewRepoStructureQueryLocalSchema: import("zod").ZodO
     reasoning: import("zod").ZodOptional<import("zod").ZodString>;
 }, import("zod/v4/core").$strip>;
 export declare const GitHubViewRepoStructureBulkQueryLocalSchema: import("zod").ZodObject<{
-    responseCharOffset: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNumber>>;
-    responseCharLength: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNumber>>;
+    responseCharOffset: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNumber>>;
+    responseCharLength: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNumber>>;
     queries: import("zod").ZodArray<import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>>;
 }, import("zod/v4/core").$strip>;
 export declare const GitHubViewRepoStructureOutputLocalSchema: import("zod").ZodObject<{
@@ -33,6 +33,8 @@ export declare const GitHubViewRepoStructureOutputLocalSchema: import("zod").Zod
             currentPage: import("zod").ZodNumber;
             totalPages: import("zod").ZodNumber;
             hasMore: import("zod").ZodBoolean;
+            nextPage: import("zod").ZodOptional<import("zod").ZodNumber>;
+            nextMatchPage: import("zod").ZodOptional<import("zod").ZodNumber>;
             perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
             totalMatches: import("zod").ZodOptional<import("zod").ZodNumber>;
             totalFiles: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -53,6 +55,8 @@ export declare const GitHubViewRepoStructureOutputLocalSchema: import("zod").Zod
         currentPage: import("zod").ZodNumber;
         totalPages: import("zod").ZodNumber;
         hasMore: import("zod").ZodBoolean;
+        nextPage: import("zod").ZodOptional<import("zod").ZodNumber>;
+        nextMatchPage: import("zod").ZodOptional<import("zod").ZodNumber>;
         perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
         totalMatches: import("zod").ZodOptional<import("zod").ZodNumber>;
         totalFiles: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -66,10 +70,10 @@ export declare const GitHubViewRepoStructureOutputLocalSchema: import("zod").Zod
         kind: import("zod").ZodString;
     }, import("zod/v4/core").$loose>]>>>;
     error: import("zod").ZodOptional<import("zod").ZodString>;
-    readonly hints: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-    readonly base: import("zod").ZodOptional<import("zod").ZodString>;
-    readonly shared: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>>;
-    readonly responsePagination: import("zod").ZodOptional<import("zod").ZodObject<{
+    hints: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    base: import("zod").ZodOptional<import("zod").ZodString>;
+    shared: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>>;
+    responsePagination: import("zod").ZodOptional<import("zod").ZodObject<{
         currentPage: import("zod").ZodNumber;
         totalPages: import("zod").ZodNumber;
         hasMore: import("zod").ZodBoolean;

package/dist/tools/local_binary_inspect/archiveOps.d.ts

@@ -20,3 +20,5 @@ export declare function listArchiveEntries(path: string, verbose: boolean): Prom
     entries?: string[];
 }>;
 export declare function extractArchiveEntry(path: string, entry: string): Promise<ArchiveChainResult>;
+/** Extracts the whole archive into destDir (which must already exist). */
+export declare function extractArchiveToDir(path: string, destDir: string): Promise<ArchiveChainResult>;

package/dist/tools/local_binary_inspect/binaryInspector.d.ts

@@ -1,9 +1,35 @@
 import type { BinaryInspectQuery } from './scheme.js';
+interface ContentCharPagination {
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    charOffset: number;
+    charLength: number;
+    totalChars: number;
+    nextCharOffset?: number;
+}
 export declare function inspectBinary(query: BinaryInspectQuery): Promise<import("../../index.js").UnifiedErrorResult | {
+    warnings?: string[];
+    truncated?: boolean;
+    detailed?: boolean;
+    libraries?: string[];
+    sections?: string[];
+    exports?: string[];
+    imports?: string[];
+    symbols?: string[];
+    symbolCount: number;
+    importCount: number;
+    exportCount: number;
+    entry?: string;
+    stripped?: boolean;
+    endianness?: string;
+    bits?: number;
+    arch?: string;
     status: "success";
-    mode: "identify";
+    mode: "inspect";
     path: string;
-    fileType: string;
+    format: string;
+    description: string;
     magicBytes: string;
 } | {
     pagination: {
@@ -20,30 +46,45 @@ export declare function inspectBinary(query: BinaryInspectQuery): Promise<import
     totalEntries: number;
     entries: string[];
 } | {
-    hints: string[];
+    pagination?: ContentCharPagination;
     status: "success";
     mode: "extract";
     path: string;
     archiveFile: string;
     backend: string;
+    localPath: string;
     content: string;
     contentLength: number;
     isPartial: boolean;
 } | {
-    hints: string[];
+    pagination?: ContentCharPagination;
     status: "success";
     mode: "decompress";
     path: string;
     format: "gzip" | "bzip2" | "xz" | "lzma" | "zstd" | "lz4" | "brotli" | "lzfse";
     backend: string;
+    localPath: string;
     content: string;
     contentLength: number;
     isPartial: boolean;
 } | {
+    nextScanOffset?: number;
+    scanOffset: number;
+    pagination?: ContentCharPagination;
+    contentLength: number;
+    totalFound: number;
+    isPartial: boolean;
+    localPath?: string;
     status: "success";
     mode: "strings";
     path: string;
-    strings: string[];
-    totalFound: number;
-    returned: number;
+    content: string;
+} | {
+    status: "success";
+    mode: "unpack";
+    path: string;
+    localPath: string;
+    cached: boolean;
+    topLevelEntries: number;
 }>;
+export {};

package/dist/tools/local_binary_inspect/binaryOps.d.ts

@@ -1,18 +1,27 @@
 /**
- * Binary file inspection.
- * Backs mode="identify" and mode="strings" in localBinaryInspect.
+ * Binary file inspection (format lane) — native, via octocode-engine.
+ * Backs mode="inspect" and mode="strings" in localBinaryInspect.
+ *
+ * No GNU binutils/coreutils dependency: `goblin`-backed parsing and a native
+ * string scanner replace the old `file` / `xxd` / `strings` shell-outs, so this
+ * lane works on Windows and on distroless/Alpine Linux, returns parser-stable
+ * structured data, and recovers UTF-16 strings GNU `strings -a` misses.
  */
-export interface IdentifyResult {
+import type { BinaryInspectInfo } from '@octocodeai/octocode-engine';
+export interface InspectResult {
     success: boolean;
-    fileType?: string;
-    magicBytes?: string;
+    info?: BinaryInspectInfo;
     error?: string;
 }
-export declare function identifyFile(path: string): Promise<IdentifyResult>;
+export declare function inspectBinaryFile(path: string): InspectResult;
 export interface StringsResult {
     success: boolean;
     strings?: string[];
     totalFound?: number;
+    /** True when more of the file remains to scan beyond this window (follow nextScanOffset). */
+    truncated?: boolean;
+    /** Absolute byte offset for the next scan window, or undefined at EOF. */
+    nextScanOffset?: number;
     error?: string;
 }
-export declare function extractStrings(path: string, minLength: number, includeOffsets: boolean): Promise<StringsResult>;
+export declare function extractStrings(path: string, minLength: number, includeOffsets: boolean, scanOffset?: number): StringsResult;

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

@@ -1,16 +1,18 @@
 import { z } from 'zod';
 export declare const LocalBinaryInspectQuerySchema: z.ZodObject<{
-    entryPageNumber: z.ZodDefault<z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>>;
-    matchStringContextLines: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    charLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    page: z.ZodDefault<z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>>;
+    entryPageNumber: z.ZodDefault<z.ZodDefault<z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>>>;
+    matchStringContextLines: z.ZodDefault<z.ZodPreprocess<z.ZodNumber>>;
+    charLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodDefault<z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>>>;
+    detailed: z.ZodOptional<z.ZodBoolean>;
     path: z.ZodString;
     mode: z.ZodEnum<{
         list: "list";
-        identify: "identify";
+        inspect: "inspect";
         extract: "extract";
         decompress: "decompress";
         strings: "strings";
+        unpack: "unpack";
     }>;
     verbose: z.ZodOptional<z.ZodBoolean>;
     maxEntries: z.ZodDefault<z.ZodNumber>;
@@ -31,6 +33,7 @@ export declare const LocalBinaryInspectQuerySchema: z.ZodObject<{
     }>>;
     minLength: z.ZodDefault<z.ZodNumber>;
     includeOffsets: z.ZodOptional<z.ZodBoolean>;
+    scanOffset: z.ZodOptional<z.ZodNumber>;
     id: z.ZodOptional<z.ZodString>;
     mainResearchGoal: z.ZodOptional<z.ZodString>;
     researchGoal: z.ZodOptional<z.ZodString>;
@@ -38,7 +41,7 @@ export declare const LocalBinaryInspectQuerySchema: z.ZodObject<{
 }, z.core.$strict>;
 export type BinaryInspectQuery = z.infer<typeof LocalBinaryInspectQuerySchema>;
 export declare const LocalBinaryInspectBulkQuerySchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    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>;

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

@@ -25,7 +25,7 @@ export type FetchContentQuery = z.infer<typeof LocalFetchContentQuerySchema> & {
     minify?: MinifyMode;
 };
 export declare const LocalFetchContentBulkQuerySchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    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>;

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

@@ -3,7 +3,7 @@ import { FindFilesQuerySchema as CoreFindFilesQuerySchema } from '@octocodeai/oc
 export type FindFilesQuery = Omit<z.infer<typeof CoreFindFilesQuerySchema>, 'regexType'>;
 export declare const LocalFindFilesQuerySchema: z.ZodType<FindFilesQuery>;
 export declare const LocalFindFilesBulkQuerySchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    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>;

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

@@ -0,0 +1,54 @@
+/**
+ * Tier 1 Phase 3 — optional, bounded LSP semantic boost for relevance ranking.
+ *
+ * Runs only for `sort:"relevance"` + `semanticRanking:true`, and only over the
+ * top-N relevance candidates already produced by the text/AST scorer. LSP
+ * enriches; it never gates. Rules (see RANKING-ARCHITECTURE.md):
+ *   1. LSP never adds or removes a result — only reorders the top-N.
+ *   2. Failure/timeout degrades to the existing text/AST order (graceful).
+ *   3. Boosts are capped and deterministic given the resolver's output.
+ *   4. An LSP boost never outweighs a strong exact declaration on its own.
+ */
+import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
+import type { FileScore } from './rankingProfile.js';
+/** What LSP can tell us about a candidate's anchor symbol. */
+export interface LspSignal {
+    isDefinition?: boolean;
+    isExportedOrPublic?: boolean;
+    hasCallers?: boolean;
+    isImplementationOrType?: boolean;
+    /** Resolver couldn't anchor / server unavailable — treated as no boost. */
+    unavailable?: boolean;
+}
+/** Capped additive boosts. Sum is bounded by LSP_BOOST_CAP. */
+export declare const LSP_BOOST: {
+    readonly definition: 3;
+    readonly exportedOrPublic: 2;
+    readonly hasCallers: 1;
+    readonly implementationOrType: 1;
+    readonly cap: 5;
+};
+export declare function lspBoostScore(signal: LspSignal | null | undefined): {
+    delta: number;
+    reasons: string[];
+};
+export type LspResolver = (file: LocalSearchCodeFile) => Promise<LspSignal | null>;
+export interface SemanticBoostResult {
+    files: LocalSearchCodeFile[];
+    /** Updated debug scores (boost folded in) keyed by path, when debug is on. */
+    debug?: Map<string, FileScore>;
+    /** True if any candidate was enriched; false means full graceful degrade. */
+    enriched: boolean;
+}
+/**
+ * Apply a bounded LSP boost to the top-N already-relevance-ranked files.
+ *
+ * `baseScores` is the Tier 1 score per path (when available). The resolver is
+ * injected so this is unit-testable and the live wiring (lspGetSemantics) stays
+ * out of the pure scoring path. Any resolver rejection degrades that one
+ * candidate to its base order; the call never throws.
+ */
+export declare function applySemanticBoost(rankedFiles: LocalSearchCodeFile[], resolve: LspResolver, opts?: {
+    topN?: number;
+    baseScores?: Map<string, FileScore>;
+}): Promise<SemanticBoostResult>;

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

@@ -0,0 +1,113 @@
+/**
+ * Tier 1 — within-source language-aware ranking for localSearchCode.
+ *
+ * Replaces "more matches first, then path" with a stable, inspectable relevance
+ * score. See `.octocode/RANKING-ARCHITECTURE.md`.
+ *
+ * Hard rules (Tier 1 determinism):
+ *  - Same inputs -> same ranking. No LLM, no clock, no randomness, no
+ *    filesystem-order dependency.
+ *  - Every score is explainable from explicit features (`debugRanking`).
+ *  - Sort is total: score desc -> raw matchCount desc -> path asc.
+ *  - Profile selection is deterministic from query + file path; unknown
+ *    languages fall back to the generic profile.
+ *
+ * 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.
+ */
+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 {};

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

@@ -2,8 +2,17 @@ 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 declare function buildSearchResult(parsedFiles: LocalSearchCodeFile[], configuredQuery: RipgrepQuery, _searchEngine: 'rg' | 'grep', warnings: string[], stats?: SearchStats): Promise<LocalSearchCodeToolResult>;
+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 {};

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

@@ -31,14 +31,36 @@ export declare const LocalRipgrepQuerySchema: z.ZodObject<{
     multilineDotall: z.ZodOptional<z.ZodBoolean>;
     sort: z.ZodDefault<z.ZodEnum<{
         path: "path";
-        modified: "modified";
         created: "created";
+        relevance: "relevance";
+        matchCount: "matchCount";
+        modified: "modified";
         accessed: "accessed";
     }>>;
     sortReverse: z.ZodOptional<z.ZodBoolean>;
+    rankingProfile: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        typescript: "typescript";
+        javascript: "javascript";
+        rust: "rust";
+        python: "python";
+        go: "go";
+        java: "java";
+        scala: "scala";
+        markdown: "markdown";
+        json: "json";
+        yaml: "yaml";
+        generic: "generic";
+    }>>;
+    debugRanking: z.ZodOptional<z.ZodBoolean>;
+    semanticRanking: z.ZodOptional<z.ZodBoolean>;
     langType: z.ZodOptional<z.ZodString>;
     countLinesPerFile: z.ZodOptional<z.ZodBoolean>;
     countMatchesPerFile: z.ZodOptional<z.ZodBoolean>;
+    onlyMatching: z.ZodOptional<z.ZodBoolean>;
+    unique: z.ZodOptional<z.ZodBoolean>;
+    countUnique: z.ZodOptional<z.ZodBoolean>;
+    matchWindow: z.ZodOptional<z.ZodNumber>;
     matchPage: z.ZodOptional<z.ZodNumber>;
     itemsPerPage: z.ZodOptional<z.ZodNumber>;
     page: z.ZodDefault<z.ZodNumber>;
@@ -47,9 +69,12 @@ export declare const LocalRipgrepQuerySchema: z.ZodObject<{
     researchGoal: z.ZodOptional<z.ZodString>;
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export type RipgrepQuery = z.infer<typeof LocalRipgrepQuerySchema>;
+export type RipgrepQuery = z.infer<typeof LocalRipgrepQuerySchema> & {
+    unique?: boolean;
+    countUnique?: boolean;
+};
 export declare const LocalRipgrepBulkQuerySchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    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>;

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

@@ -1,9 +1,8 @@
 import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-types';
 import type { RipgrepQuery } from './scheme.js';
 /**
- * mode:"structural" execution path. Resolves candidate files, pre-filters them
- * with a literal anchor when the pattern provides one, runs the AST engine per
- * file, and reuses the ripgrep result builder so the output shape (pagination,
- * sizing) is identical to the other localSearchCode modes.
+ * mode:"structural" execution path. Path validation and result shaping stay in
+ * TypeScript with the rest of localSearchCode; 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_view_structure/scheme.d.ts

@@ -27,7 +27,7 @@ export declare const LocalViewStructureQuerySchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ViewStructureQuery = z.infer<typeof LocalViewStructureQuerySchema>;
 export declare const LocalViewStructureBulkQuerySchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    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>;

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

@@ -11,12 +11,10 @@ export interface DirectoryEntry {
 }
 type EntryFilterQuery = Pick<{
     pattern?: string;
-    extensions?: string[];
     directoriesOnly?: boolean;
     filesOnly?: boolean;
-}, 'pattern' | 'extensions' | 'directoriesOnly' | 'filesOnly'>;
+}, 'pattern' | 'directoriesOnly' | 'filesOnly'>;
 export declare function applyEntryFilters(entries: DirectoryEntry[], query: EntryFilterQuery): DirectoryEntry[];
-export declare function formatEntryString(entry: DirectoryEntry, indent?: number): string;
 interface EntryOutput {
     type: 'file' | 'dir' | 'link';
     depth?: number;

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

@@ -21,6 +21,7 @@ export declare function paginateEntries(entries: DirectoryEntry[], query: {
         entriesPerPage: number;
         totalEntries: number;
         hasMore: boolean;
+        nextPage?: number;
     };
 };
 export declare function buildEntryPaginationHints(entries: DirectoryEntry[], paginatedCount: number, pagination: {