@octocodeai/octocode-tools-core 18.3.0 → 19.1.0

package/dist/tools/github_search_repos/execution/pagination.d.ts

@@ -1,4 +1,3 @@
-import type { RepoSearchVariantExecution, RepoSearchVariantLabel, SuccessfulRepoSearchVariant } from './queryVariants.js';
 export declare function buildResultPagination(pagination: {
     currentPage: number;
     totalPages?: number;
@@ -21,19 +20,3 @@ export declare function buildResultPagination(pagination: {
     totalPages?: number;
     currentPage: number;
 };
-export type EffectivePagination = {
-    currentPage: number;
-    totalPages?: number;
-    hasMore: boolean;
-    entriesPerPage?: number;
-    totalMatches?: number;
-    reportedTotalMatches?: number;
-    reachableTotalMatches?: number;
-    totalMatchesKind?: 'exact' | 'reported' | 'lowerBound';
-    totalMatchesCapped?: boolean;
-};
-export declare function buildPartialFailureWarnings(failedVariants: readonly {
-    label: RepoSearchVariantLabel;
-}[]): string[] | undefined;
-export declare function buildMergedPagination(variants: SuccessfulRepoSearchVariant[], dedupedCount: number): EffectivePagination | undefined;
-export declare function sumVariantRawResponseChars(variants: RepoSearchVariantExecution[]): number;

package/dist/tools/github_search_repos/execution/queryVariants.d.ts

@@ -1,7 +1,5 @@
 import type { z } from 'zod';
-import type { GitHubReposSearchSingleQuerySchema } from '../../../toolContract/schemas.js';
-import type { RepoSearchResult as ProviderRepoSearchResult } from '../../../providers/types.js';
-import type { ProviderOperationResult } from '../../providerExecution.js';
+import type { GitHubReposSearchSingleQuerySchema } from '../../../toolContract/input/resources/tools/githubRepositoriesOperation.js';
 import type { WithOptionalMeta } from '../../../types/execution.js';
 type GitHubReposSearchSingleQuery = z.infer<typeof GitHubReposSearchSingleQuerySchema>;
 export type RepositorySearchExtraFields = {
@@ -14,27 +12,7 @@ export type RepositorySearchExtraFields = {
     size?: string;
 };
 export type PartialReposSearchQuery = WithOptionalMeta<GitHubReposSearchSingleQuery> & RepositorySearchExtraFields;
-export type RepoSearchVariantLabel = 'combined' | 'topics' | 'keywords';
-export interface RepoSearchVariant {
-    label: RepoSearchVariantLabel;
-    query: PartialReposSearchQuery;
-}
-export interface RepoSearchVariantExecution {
-    label: RepoSearchVariantLabel;
-    query: PartialReposSearchQuery;
-    response: ProviderOperationResult<RepoSearchVariant, ProviderRepoSearchResult>['response'];
-}
-export type SuccessfulRepoSearchVariant = RepoSearchVariantExecution & {
-    response: Extract<ProviderOperationResult<RepoSearchVariant, ProviderRepoSearchResult>, {
-        response: {
-            data: ProviderRepoSearchResult;
-        };
-    }>['response'] & {
-        data: ProviderRepoSearchResult;
-    };
-};
 export declare function hasValidTopics(query: PartialReposSearchQuery): boolean;
 export declare function hasValidKeywords(query: PartialReposSearchQuery): boolean;
 export declare function hasValidRepositorySearchParams(query: PartialReposSearchQuery): boolean;
-export declare function createSearchVariants(query: PartialReposSearchQuery): RepoSearchVariant[];
 export {};

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

@@ -2,6 +2,5 @@ import type { CallToolResult } from '@modelcontextprotocol/server';
 import type { ToolExecutionArgs } from '../../types/execution.js';
 import type { ProcessedBulkResult } from '../../types/toolResults.js';
 import { type PartialReposSearchQuery } from './execution/queryVariants.js';
-export { buildMergedPagination, buildPartialFailureWarnings, buildResultPagination, } from './execution/pagination.js';
 export declare function searchGitHubRepos(query: PartialReposSearchQuery, args: ToolExecutionArgs<PartialReposSearchQuery>, getProviderContext?: () => import("../providerExecution.js").ProviderExecutionContext): Promise<ProcessedBulkResult>;
 export declare function searchMultipleGitHubRepos(args: ToolExecutionArgs<PartialReposSearchQuery>): Promise<CallToolResult>;

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

@@ -13,16 +13,16 @@ export declare const GitHubReposSearchSingleQueryLocalSchema: z.ZodObject<{
     created: z.ZodOptional<z.ZodString>;
     size: z.ZodOptional<z.ZodString>;
     match: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        name: "name";
         description: "description";
+        name: "name";
         readme: "readme";
     }>>>;
     sort: z.ZodDefault<z.ZodEnum<{
-        updated: "updated";
-        "best-match": "best-match";
         stars: "stars";
+        updated: "updated";
         forks: "forks";
         "help-wanted-issues": "help-wanted-issues";
+        "best-match": "best-match";
     }>>;
     limit: z.ZodDefault<z.ZodNumber>;
     page: z.ZodDefault<z.ZodNumber>;
@@ -37,9 +37,9 @@ export declare const GitHubReposSearchSingleQueryLocalSchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const GitHubReposSearchBulkQueryLocalSchema: 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>>>;
+    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    queries: z.ZodArray<z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strict>;
 export interface LocalRepositoryDetail {
     owner: string;

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

@@ -1,6 +1,6 @@
 import type { CallToolResult } from '@modelcontextprotocol/server';
 import type { z } from 'zod';
-import type { GitHubViewRepoStructureQuerySchema } from '../../toolContract/schemas.js';
+import type { GitHubViewRepoStructureQuerySchema } from '../../toolContract/input/resources/tools/githubTreeOperation.js';
 import type { GitHubRepoStructureDirectoryEntry } from '@octocodeai/octocode-core/extra-types';
 type GitHubViewRepoStructureQuery = z.infer<typeof GitHubViewRepoStructureQuerySchema>;
 import type { WithOptionalMeta } from '../../types/execution.js';

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

@@ -7,21 +7,22 @@ export declare const GitHubViewRepoStructureQueryLocalSchema: import("zod").ZodO
     path: import("zod").ZodOptional<import("zod").ZodString>;
     maxDepth: import("zod").ZodOptional<import("zod").ZodNumber>;
     page: import("zod").ZodDefault<import("zod").ZodNumber>;
+    metadataPage: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
     itemsPerPage: import("zod").ZodDefault<import("zod").ZodNumber>;
     include: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
-        sizes: "sizes";
-        languages: "languages";
         contributors: "contributors";
         branches: "branches";
         tags: "tags";
+        languages: "languages";
+        sizes: "sizes";
     }>>>;
     goal: import("zod").ZodOptional<import("zod").ZodString>;
     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").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>>>;
+    responseCharOffset: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNumber, unknown>>;
+    responseCharLength: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNumber, unknown>>;
+    queries: import("zod").ZodArray<import("zod").ZodTypeAny<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>>;
 }, import("zod/v4/core").$strict>;
 export interface StructureDirEntry {
     dir?: string;

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

@@ -1,8 +1,10 @@
 import type { WalkResult } from '../../graph/buildFileGraph.js';
+import type { GraphCoverage } from '../../graph/types.js';
 export type GraphOperation = 'deadCode' | 'cycles' | 'dependencies' | 'dependents' | 'path' | 'reachability';
 export interface AnalyzeGraphQuery {
     operation: GraphOperation;
-    path: string;
+    /** Absolute repo/package root to scan. Inferred from `file` when omitted and `file` is absolute. */
+    path?: string;
     file?: string;
     target?: string;
     depth?: number;
@@ -13,6 +15,10 @@ export interface AnalyzeGraphQuery {
     limit?: number;
     page?: number;
     pageSize?: number;
+    diagnosticPage?: number;
+    diagnosticPageSize?: number;
+    diagnosticSnapshot?: string;
+    rustWorkspace?: 'syntax' | 'cargo';
 }
 export interface AnalyzeGraphOutput {
     status?: 'empty' | 'error';
@@ -24,7 +30,14 @@ export interface AnalyzeGraphOutput {
     filesSkipped?: number;
     truncated?: boolean;
     terminalLimit?: boolean;
-    partialReasons?: Array<'maxFiles' | 'limit' | 'filesSkipped'>;
+    completeness?: {
+        results: 'complete' | 'pageable' | 'truncated';
+        graph: 'complete' | 'scan-truncated' | 'coverage-incomplete';
+        diagnostics: 'complete' | 'pageable' | 'truncated';
+        coverageGapReasons?: Array<'parseRecovery' | 'unresolvedImports' | 'unsupportedLinking'>;
+    };
+    partialReasons?: Array<'maxFiles' | 'limit' | 'filesSkipped' | 'parseRecovery' | 'unresolvedImports' | 'unsupportedLinking' | 'diagnosticPage'>;
+    coverage?: GraphCoverage;
     totalAvailable?: number;
     results: Array<Record<string, unknown>>;
     summary?: Record<string, unknown>;
@@ -42,5 +55,5 @@ export interface AnalyzeGraphOutput {
     [key: string]: unknown;
 }
 export interface AnalyzeGraphContext {
-    getGraph?: (path: string, excludeDir: string[], maxFiles: number) => WalkResult | Promise<WalkResult>;
+    getGraph?: (path: string, excludeDir: string[], maxFiles: number, rustWorkspace?: 'syntax' | 'cargo') => WalkResult | Promise<WalkResult>;
 }

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

@@ -1,3 +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>;
+export declare function analyzeGraph(rawQuery: AnalyzeGraphQuery, context?: AnalyzeGraphContext): Promise<AnalyzeGraphOutput>;

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

@@ -0,0 +1,3 @@
+import type { AnalyzeGraphOutput } from './analysisTypes.js';
+/** Keep result, graph, and diagnostic completeness independent and explicit. */
+export declare function attachGraphCompleteness(output: AnalyzeGraphOutput): AnalyzeGraphOutput;

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

@@ -1,7 +1,8 @@
 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>;
+import type { DeadClusterOutput, DeadExportOutput, AnalyzeGraphQuery } from './scheme.js';
+type DeadCodeScanOptions = Partial<Pick<Extract<AnalyzeGraphQuery, {
+    operation: 'deadCode';
+}>, 'excludeDir' | 'maxFiles' | 'rustWorkspace' | 'entrypoints' | 'includeTests'>>;
 export interface DeadCodeScanResult {
     filesScanned: number;
     filesSkipped: number;
@@ -11,7 +12,7 @@ export interface DeadCodeScanResult {
     warnings: string[];
     /**
      * Present (and always `"low"`) when the scan's reachability base is shaky, so
-     * the raw candidate count should not be trusted as-is. Two triggers, each
+     * the raw candidate count should not be trusted as-is. Triggers, each
      * with its own explanatory `warnings` entry:
      *  - `entrypointsResolved` came entirely from the test-file heuristic (no
      *    package.json main/exports/bin matched and no explicit `entrypoints`),
@@ -20,8 +21,11 @@ export interface DeadCodeScanResult {
      *  - one or more resolved entrypoints parsed to zero edges (a native
      *    extractor parse failure on that file), so reachability can't leave them
      *    and files they should reach show as false "unreachable-file".
+     *  - The scan was capped, files were skipped, or coverage diagnostics report
+     *    parse recovery or unsupported/unresolved import linking. Missing edges
+     *    can hide live paths even when entrypoints contain valid declarations.
      */
     confidence?: 'low';
 }
-export declare function scanForDeadCode(rootAbsolutePath: string, query: FindDeadCodeQuery, builtGraph?: WalkResult): Promise<DeadCodeScanResult>;
+export declare function scanForDeadCode(rootAbsolutePath: string, query: DeadCodeScanOptions, builtGraph?: WalkResult): Promise<DeadCodeScanResult>;
 export {};

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

@@ -0,0 +1,2 @@
+/** Prefer the nearest Cargo manifest for Rust; wider workspace scans need an explicit path. */
+export declare function inferRootFromAbsoluteFile(absoluteFile: string, rustWorkspace?: 'syntax' | 'cargo'): string;

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

@@ -1,12 +1,13 @@
 import { z } from 'zod';
 import type { LocalItemPagination, ToolContinuation } from '../../scheme/pagination.js';
-import { LocalAnalyzeGraphQuerySchema } from '../../toolContract/schemas.js';
+import { LocalAnalyzeGraphQuerySchema } from '../../toolContract/input/resources/tools/localAnalyzeGraph.js';
+import type { GraphCoverage } from '../../graph/types.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>>>;
+    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    queries: z.ZodArray<z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strict>;
 export type GraphOperation = AnalyzeGraphQuery['operation'];
 export type DeadCodeReason = 'unreachable-file' | 'unreferenced-export' | 'dead-cluster';
@@ -25,6 +26,7 @@ export interface DeadClusterOutput {
     reason: string;
 }
 export interface AnalyzeGraphOutput {
+    coverage?: GraphCoverage;
     status?: 'empty' | 'error';
     error?: string;
     errorCode?: string;
@@ -35,7 +37,13 @@ export interface AnalyzeGraphOutput {
     filesSkipped?: number;
     truncated?: boolean;
     terminalLimit?: boolean;
-    partialReasons?: Array<'maxFiles' | 'limit' | 'filesSkipped'>;
+    completeness?: {
+        results: 'complete' | 'pageable' | 'truncated';
+        graph: 'complete' | 'scan-truncated' | 'coverage-incomplete';
+        diagnostics: 'complete' | 'pageable' | 'truncated';
+        coverageGapReasons?: Array<'parseRecovery' | 'unresolvedImports' | 'unsupportedLinking'>;
+    };
+    partialReasons?: Array<'maxFiles' | 'limit' | 'filesSkipped' | 'parseRecovery' | 'unresolvedImports' | 'unsupportedLinking' | 'diagnosticPage'>;
     totalAvailable?: number;
     results?: Array<Record<string, unknown>>;
     summary?: Record<string, unknown>;
@@ -45,23 +53,3 @@ export interface AnalyzeGraphOutput {
     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;
-    errorCode?: string;
-    rawResponseChars?: number;
-    path?: string;
-    filesScanned?: number;
-    filesSkipped?: number;
-    entrypointsResolved?: string[];
-    deadExports?: DeadExportOutput[];
-    deadClusters?: DeadClusterOutput[];
-    pagination?: LocalItemPagination;
-    next?: Record<string, ToolContinuation>;
-    confidence?: 'low';
-    warnings?: string[];
-    [key: string]: unknown;
-}

package/dist/tools/local_fetch_content/fetchContent/pagination.d.ts

@@ -4,6 +4,13 @@ import type { FetchContentQuery } from '../scheme.js';
 import { type FileStats } from './validation.js';
 import type { ExtractionState } from './extraction.js';
 export type ContentView = 'none' | 'standard' | 'symbols';
+/** Sanitize a complete extracted view before character offsets are assigned. */
+export declare function sanitizeReturnedText(text: string, queryPath: string): {
+    text: string;
+    warning?: string;
+    limited: boolean;
+};
+export declare function buildSecurityLimitResult(query: FetchContentQuery, totalLines: number, firstSelectedLine?: number): LocalGetFileContentToolResult;
 export interface ContentWindow {
     /** The windowed (paginated) slice of the input content. */
     windowedContent: string;

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

@@ -25,9 +25,9 @@ export type FetchContentQuery = z.infer<typeof LocalFetchContentQuerySchema> & {
     minify?: MinifyMode;
 };
 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>>>;
+    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    queries: z.ZodArray<z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strict>;
 export interface FileContentMatchRange {
     start: number;

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

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { FindFilesQuerySchema } from '../../toolContract/schemas.js';
+import type { FindFilesQuerySchema } from '../../toolContract/input/resources/tools/localFilesOperation.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/scheme.d.ts

@@ -1,13 +1,13 @@
 import { z } from 'zod';
-import { FindFilesQuerySchema as CoreFindFilesQuerySchema } from '../../toolContract/schemas.js';
+import { FindFilesQuerySchema as CoreFindFilesQuerySchema } from '../../toolContract/input/resources/tools/localFilesOperation.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'>;
 export declare const LocalFindFilesQuerySchema: z.ZodType<FindFilesQuery>;
 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>>>;
+    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    queries: z.ZodArray<z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strict>;
 export interface LocalFindFilesEntryOutput {
     name?: string;

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

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

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

@@ -1,8 +1,7 @@
 /**
  * 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.
+ * `.octocode/RANKING-ARCHITECTURE.md` for the ranking 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.

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

@@ -6,8 +6,8 @@
  * `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.
+ * and produces a total, deterministic order: score descending, match count
+ * descending, then path ascending. Equal inputs always produce equal rankings.
  */
 import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
 import type { RankSort } from './rankingProfiles.js';

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

@@ -6,7 +6,7 @@
  * order they are computed. Do not reorder the calls inside
  * `scoreFileWithRarity` or `bestLineScore`.
  *
- * See the module doc in `../rankingProfile.ts` for the full contract.
+ * Weight policy and profile selection live in rankingProfiles.ts.
  */
 import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
 import { type PathRole, type RankingProfileId } from './rankingProfiles.js';
@@ -36,6 +36,4 @@ type CandidateTermRarity = {
 };
 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/ripgrepResultBuilder/buildResult.d.ts

@@ -4,7 +4,3 @@ 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

@@ -35,6 +35,7 @@ export declare function buildSearchNextMap(files: LocalSearchCodeFile[], query:
     matchPage: number;
     matchesPerPage: number;
     hasFileWithMoreMatches: boolean;
+    scanCapReached?: boolean;
 }): SearchNextMap;
 export type InferredLspSymbol = {
     symbol: string;

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

@@ -49,8 +49,8 @@ export declare const LocalRipgrepQuerySchema: z.ZodObject<{
     }>>;
     sortReverse: z.ZodOptional<z.ZodBoolean>;
     rankingProfile: z.ZodDefault<z.ZodEnum<{
-        typescript: "typescript";
         auto: "auto";
+        typescript: "typescript";
         javascript: "javascript";
         rust: "rust";
         python: "python";
@@ -86,9 +86,9 @@ export declare const LocalRipgrepQuerySchema: z.ZodObject<{
 }, z.core.$strip>;
 export type RipgrepQuery = z.infer<typeof LocalRipgrepQuerySchema>;
 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>>>;
+    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber, unknown>>;
+    queries: z.ZodArray<z.ZodTypeAny<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strict>;
 export interface LocalSearchMatch {
     line: number;
@@ -146,6 +146,14 @@ export interface LocalSearchCodeData {
     next?: Record<string, ToolContinuation>;
     terminalLimit?: boolean;
     truncated?: boolean;
-    partialReasons?: Array<'maxFiles'>;
+    partialReasons?: Array<'maxFiles' | 'structuralLimit' | 'skippedFiles'>;
+    diagnostics?: Array<{
+        code: string;
+        severity: string;
+        stage: string;
+        message: string;
+        path?: string;
+        recovery?: string;
+    }>;
 }
 export type LocalSearchCodeOutput = BulkToolOutput<LocalSearchCodeData>;

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

@@ -0,0 +1,9 @@
+import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-types';
+import type { StructuralDiagnostic, StructuralSearchFilesResult } from '@octocodeai/octocode-engine';
+import type { LocalSearchCodeData } from './scheme.js';
+type StructuralToolResult = LocalSearchCodeToolResult & Pick<LocalSearchCodeData, 'truncated' | 'terminalLimit' | 'partialReasons' | 'diagnostics'>;
+export declare function isIncomplete(result: StructuralSearchFilesResult): boolean;
+export declare function withCompleteness(result: LocalSearchCodeToolResult, status: string, diagnostics: StructuralDiagnostic[]): StructuralToolResult;
+export declare function executionLimitDiagnostic(message: string, path: string): StructuralDiagnostic | undefined;
+export declare function rewrittenQueryDiagnostic(requestedPattern: string | undefined, executedPattern: string | undefined, path: string): StructuralDiagnostic | undefined;
+export {};

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

@@ -1,5 +1,4 @@
 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>;