@octocodeai/octocode-tools-core 17.0.2 → 18.0.1

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

@@ -9,6 +9,12 @@ export interface ExtractionState {
         start: number;
         end: number;
     }>;
+    /**
+     * Exact matched-line numbers (as opposed to `matchRanges`, which are
+     * ±contextLines windows around them) — previously only readable by parsing
+     * the "Found ... on line N" prose in `warnings`.
+     */
+    matchedLines?: number[];
     warnings?: string[];
     earlyResult?: LocalGetFileContentToolResult;
 }

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

@@ -15,7 +15,15 @@ export declare function getFileStatsOrError(query: FetchContentQuery, absolutePa
     fileStats?: FileStats;
     errorResult?: LocalGetFileContentToolResult;
 }>;
-export declare function shouldFailForLargeFile(query: FetchContentQuery, fileSizeKB: number): boolean;
+/**
+ * The effective minify mode a read will use, resolved the same way
+ * `fetchContent` resolves it: an explicit `minify` always wins; otherwise
+ * `fullContent`/a line range defaults to `'none'` (verbatim), and every other
+ * read defaults to `'standard'`. Exposed so the large-file gate can be
+ * computed from the *actual* read mode instead of duplicating this ternary.
+ */
+export declare function resolveMinifyMode(query: FetchContentQuery): 'none' | 'standard' | 'symbols';
+export declare function shouldFailForLargeFile(query: FetchContentQuery, fileSizeKB: number, minifyMode: 'none' | 'standard' | 'symbols'): boolean;
 export declare function createLargeFileErrorResult(query: FetchContentQuery, absolutePath: string, fileSizeKB: number): LocalGetFileContentToolResult;
 export declare function createBinaryFileErrorResult(query: FetchContentQuery, absolutePath: string): LocalGetFileContentToolResult;
 export declare function isLikelyBinaryFile(filePath: string): Promise<boolean>;

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

@@ -3,4 +3,3 @@ import type { FetchContentQuery } from './scheme.js';
 import { type ContentView } from './fetchContent/pagination.js';
 export type { ContentView };
 export declare function fetchContent(query: FetchContentQuery): Promise<LocalGetFileContentToolResult>;
-export declare function finalizeFetchContentResult(result: LocalGetFileContentToolResult, _query: FetchContentQuery, _totalLines: number): LocalGetFileContentToolResult;

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

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { type MinifyMode } from '../../scheme/fields.js';
+import type { CharPagination, ItemPagination, ToolContinuation } from '../../scheme/pagination.js';
+import type { BulkToolOutput } from '../../types/toolOutput.js';
 export declare const LocalFetchContentQuerySchema: z.ZodObject<{
     path: z.ZodString;
     fullContent: z.ZodOptional<z.ZodBoolean>;
@@ -29,93 +31,29 @@ export declare const LocalFetchContentBulkQuerySchema: z.ZodObject<{
     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 LocalGetFileContentOutputSchema: z.ZodObject<{
-    results: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodOptional<z.ZodEnum<{
-            empty: "empty";
-            error: "error";
-        }>>;
-        data: z.ZodObject<{
-            path: z.ZodOptional<z.ZodString>;
-            content: z.ZodOptional<z.ZodString>;
-            contentView: z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                standard: "standard";
-                symbols: "symbols";
-            }>>;
-            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>;
-            matchRanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                start: z.ZodNumber;
-                end: z.ZodNumber;
-            }, z.core.$strip>>>;
-            pagination: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-                charOffset: z.ZodNumber;
-                charLength: z.ZodNumber;
-                totalChars: z.ZodNumber;
-                hasMore: z.ZodBoolean;
-                nextCharOffset: z.ZodOptional<z.ZodNumber>;
-                currentPage: z.ZodOptional<z.ZodNumber>;
-                totalPages: z.ZodOptional<z.ZodNumber>;
-                chunkMode: z.ZodOptional<z.ZodEnum<{
-                    semantic: "semantic";
-                    "char-limit": "char-limit";
-                }>>;
-                nextBlockChar: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>, 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>;
-                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>;
-            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            matchNotFound: z.ZodOptional<z.ZodBoolean>;
-            searchedFor: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-    }, z.core.$strip>>;
-    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;
-        charOffset: z.ZodNumber;
-        charLength: z.ZodNumber;
-        totalChars: z.ZodNumber;
-        nextCharOffset: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type LocalGetFileContentOutput = z.infer<typeof LocalGetFileContentOutputSchema>;
+export interface FileContentMatchRange {
+    start: number;
+    end: number;
+}
+export interface LocalGetFileContentData {
+    path?: string;
+    content?: string;
+    contentView?: 'none' | 'standard' | 'symbols';
+    totalLines?: number;
+    sourceChars?: number;
+    sourceBytes?: number;
+    returnedChars?: number;
+    startLine?: number;
+    endLine?: number;
+    isPartial?: boolean;
+    matchRanges?: FileContentMatchRange[];
+    pagination?: (CharPagination & {
+        nextBlockChar?: number;
+    }) | ItemPagination;
+    next?: Record<string, ToolContinuation>;
+    modified?: string;
+    warnings?: string[];
+    matchNotFound?: boolean;
+    searchedFor?: string;
+}
+export type LocalGetFileContentOutput = BulkToolOutput<LocalGetFileContentData>;

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

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

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

@@ -5,7 +5,4 @@ type UpstreamFindFilesQuery = z.infer<typeof FindFilesQuerySchema>;
 import type { WithOptionalMeta } from '../../types/execution.js';
 type FindFilesQuery = WithOptionalMeta<UpstreamFindFilesQuery>;
 export declare function findFiles(query: FindFilesQuery): Promise<LocalFindFilesToolResult>;
-export declare function finalizeFindFilesResult(result: LocalFindFilesToolResult, _query: FindFilesQuery, _totals: {
-    totalFiles: number;
-}): LocalFindFilesToolResult;
 export {};

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

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

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

@@ -0,0 +1,20 @@
+import type { FileSystemQueryResult } from '../../utils/contextUtils.js';
+/**
+ * Expand shell-style brace alternation (`{a,b,c}`) in a glob pattern into the
+ * cartesian product of concrete patterns. The native glob compiler (a
+ * hand-rolled glob-to-regex translator, see `octocode-engine`'s `fs_query.rs`)
+ * has no brace support — a pattern like `packages/{react,react-reconciler}/**`
+ * previously compiled to a regex that silently matched nothing, with no error.
+ * Returns the input unchanged as a single-element array when it has no brace
+ * groups, so patterns without braces see no behavior change.
+ */
+export declare function expandBracePattern(pattern: string): string[];
+/**
+ * Merge multiple native `queryFileSystem` results (one per expanded brace
+ * alternative) into a single result shape, deduping entries that matched more
+ * than one alternative. `totalDiscovered`/`skipped`/`permissionDenied` are
+ * summed per-walk (not deduped) — each expanded pattern walks the tree
+ * independently, so this is an upper bound on true unique discovery, not an
+ * exact count; `wasCapped` is true if any alternative hit its cap.
+ */
+export declare function mergeFileSystemQueryResults(results: readonly FileSystemQueryResult[]): FileSystemQueryResult;

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

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { FindFilesQuerySchema as CoreFindFilesQuerySchema } from '@octocodeai/octocode-core/schemas';
+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<{
@@ -7,84 +9,20 @@ export declare const LocalFindFilesBulkQuerySchema: z.ZodObject<{
     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 LocalFindFilesOutputSchema: z.ZodObject<{
-    results: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodOptional<z.ZodEnum<{
-            empty: "empty";
-            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>;
-                type: z.ZodOptional<z.ZodEnum<{
-                    file: "file";
-                    link: "link";
-                    directory: "directory";
-                    dir: "dir";
-                    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>;
-                permissions: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-            summary: z.ZodOptional<z.ZodString>;
-            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;
-                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>>;
-    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;
-        charOffset: z.ZodNumber;
-        charLength: z.ZodNumber;
-        totalChars: z.ZodNumber;
-        nextCharOffset: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type LocalFindFilesOutput = z.infer<typeof LocalFindFilesOutputSchema>;
+export interface LocalFindFilesEntryOutput {
+    name?: string;
+    path?: string;
+    type?: 'file' | 'dir' | 'directory' | 'link' | 'symlink';
+    size?: number | string;
+    sizeFormatted?: string;
+    modified?: string;
+    permissions?: string;
+}
+export interface LocalFindFilesData {
+    path?: string;
+    files?: LocalFindFilesEntryOutput[];
+    summary?: string;
+    pagination?: LocalItemPagination;
+    next?: Record<string, ToolContinuation>;
+}
+export type LocalFindFilesOutput = BulkToolOutput<LocalFindFilesData>;

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

@@ -0,0 +1,25 @@
+export type MetavarRange = {
+    text: string;
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+};
+/**
+ * Apply the default capture budget to one match's metavar payload.
+ *
+ * `$$$` list captures (bodies, argument lists) serialize every statement
+ * TWICE (metavars text + metavarRanges text) — for a handful of function
+ * matches that is tens of KB of duplicated source an agent almost never
+ * needs: the ranges are the useful part (LSP anchors). Default policy:
+ *  - `metavars`: keep single-entry captures (cheap, high-value anchors like
+ *    `$NAME`), drop multi-entry list captures entirely.
+ *  - `metavarRanges`: always keep (they are the anchors), but prune
+ *    comment-only entries from list captures and truncate each entry's text
+ *    to CAPTURE_TEXT_BUDGET chars (marked with `…`).
+ * `captureText:true` restores the verbatim engine payload.
+ */
+export declare function budgetCaptures(metavars: Record<string, string[]> | undefined | null, metavarRanges: Record<string, MetavarRange[]> | undefined | null, captureText: boolean): {
+    metavars?: Record<string, string[]>;
+    metavarRanges?: Record<string, MetavarRange[]>;
+};

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

@@ -32,6 +32,7 @@ export declare const RANK_WEIGHTS: {
     readonly extMatchesLangType: 2;
     readonly sourceDir: 1.5;
     readonly lowSignalPathPenalty: -5;
+    readonly testPathPenalty: -3.5;
     readonly rareQueryTokenScale: 2;
     readonly rareQueryTokenCap: 3;
     readonly matchCountScale: 1.5;

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

@@ -27,6 +27,7 @@ export interface RankResult {
 export declare function rankFiles(files: LocalSearchCodeFile[], sort: RankSort, ctx: RankContext, opts?: {
     debug?: boolean;
     candidateCap?: number;
+    sortReverse?: boolean;
 }): RankResult;
 export declare function matchesAny(patterns: readonly RegExp[], line: string): boolean;
 export declare function escapeRegex(s: string): string;

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

@@ -2,7 +2,7 @@ import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
 import type { RipgrepQuery } from '../scheme.js';
 import type { LocalSearchEngine } from './buildResult.js';
 type NextToolName = 'localGetFileContent' | 'lspGetSemantics' | 'localSearchCode';
-type NextConfidence = 'exact' | 'heuristic';
+type NextConfidence = 'exact' | 'low';
 type SearchNextCall = {
     tool: NextToolName;
     query: Record<string, unknown>;