@octocodeai/octocode-tools-core 16.3.0 → 16.6.0

package/dist/tools/directToolCatalog.meta.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Engine-free direct-tool catalog metadata (P3).
+ *
+ * This module holds EVERYTHING the schema/help/`--scheme`/`context` paths need
+ * — tool definitions (name + display/bulk zod schemas), schema-text formatters,
+ * display-field extraction, example builders, and input preparation — WITHOUT
+ * importing `@octocodeai/octocode-engine` (no native `.node` load at module
+ * eval). The schemas are sourced from each tool's engine-free `scheme.ts`, the
+ * same modules `toolConfig.ts` consumes, so the two cannot drift on shape (a
+ * drift test asserts name/schema parity against the runtime `ALL_TOOLS`).
+ *
+ * The execution path (`executeDirectTool`) lives in `directToolCatalog.exec.ts`,
+ * which DOES import the engine; it is only reached when a tool actually runs.
+ * The `@octocodeai/octocode-tools-core/schema` subpath re-exports only this
+ * module so engine-less runtimes (e.g. Codex.app Node) can read schemas.
+ */
+import { z } from 'zod';
+export type DirectToolInput = Record<string, unknown> & {
+    queries: unknown[];
+};
+export interface DirectToolDefinition {
+    name: string;
+    schema: z.ZodType;
+    inputSchema: z.ZodType;
+}
+export type DirectToolCategory = 'GitHub' | 'Local Code' | 'Package' | 'Other';
+export declare const DIRECT_TOOL_CATEGORIES: readonly DirectToolCategory[];
+export interface DirectToolDisplayField {
+    name: string;
+    required: boolean;
+    type: string;
+    /** Numeric bounds and default, e.g. "1-100, default 30" — surfaced inline so
+     * agents see the full constraint without fetching the raw JSON schema. */
+    constraints?: string;
+    description?: string;
+}
+export interface DirectToolCommandPattern {
+    label: string;
+    query: Record<string, unknown>;
+    command: string;
+}
+export interface DirectToolOutputField {
+    name: string;
+    type: string;
+    optional?: boolean;
+}
+export interface DirectToolMetadata {
+    tools?: Record<string, {
+        description?: string;
+        schema?: Record<string, string>;
+    }>;
+}
+export interface PrepareDirectToolInputOptions {
+    sourceLabel?: string;
+    onUnknownFields?: (unknownFields: string[], queryIndex: number) => void;
+}
+export declare class DirectToolInputError extends Error {
+    readonly details: string[];
+    constructor(message: string, details?: string[]);
+}
+/**
+ * Engine-free tool definitions (name + display/bulk schema). Order mirrors
+ * `ALL_TOOLS` in `toolConfig.ts`; each schema is the SAME object that
+ * `toolConfig` attaches an executionFn to. Kept in lockstep by a drift test.
+ */
+export declare const DIRECT_TOOL_DEFINITIONS: DirectToolDefinition[];
+export declare function findDirectToolDefinition(name: string): DirectToolDefinition | undefined;
+export declare function getDirectToolCategory(toolName: string): DirectToolCategory;
+export declare function sortDirectToolNames(toolNames: string[]): string[];
+export declare function formatDirectToolSchemaText(toolName: string): string;
+export declare function formatDirectToolMetadataSchemaText(schema: Record<string, string> | undefined): string;
+export declare function getDirectToolAutoFilledFields(toolName: string): string[];
+export declare function getDirectToolOutputFields(): DirectToolOutputField[];
+export declare function formatDirectToolOutputSchemaText(): string;
+export declare function getDirectToolDescription(toolName: string, metadata?: DirectToolMetadata | null): string;
+export declare function getDirectToolDisplayFields(toolName: string): DirectToolDisplayField[];
+export declare function formatDirectToolCommandPattern(toolName: string, query: Record<string, unknown>): string;
+export declare function buildDirectToolCommandPatterns(toolName: string): DirectToolCommandPattern[];
+export declare function buildDirectToolExampleQuery(toolName: string): Record<string, unknown>;
+export declare function prepareDirectToolInputFromJsonText(toolName: string, inputText: string | undefined, options?: PrepareDirectToolInputOptions): DirectToolInput | null;
+export declare function prepareDirectToolInput(toolName: string, rawPayload: unknown, options?: PrepareDirectToolInputOptions): DirectToolInput;
+export declare function formatDirectToolValidationIssues(error: z.ZodError): string[];

package/dist/tools/github_clone_repo/cache.d.ts

@@ -1,6 +1,9 @@
 import type { CloneCacheMeta, CacheSource } from './types.js';
 export declare function getReposBaseDir(octocodeDir: string): string;
+export declare function getCloneBaseDir(octocodeDir: string): string;
+export declare function getTreeBaseDir(octocodeDir: string): string;
 export declare function getCloneDir(octocodeDir: string, owner: string, repo: string, branch: string, sparsePath?: string): string;
+export declare function getTreeDir(octocodeDir: string, owner: string, repo: string, branch: string): string;
 export declare function readCacheMeta(cloneDir: string): CloneCacheMeta | null;
 export declare function writeCacheMeta(cloneDir: string, meta: CloneCacheMeta): void;
 export declare function isCacheValid(meta: CloneCacheMeta): boolean;
@@ -13,9 +16,10 @@ export declare function isCacheHit(cloneDir: string): {
 export declare function getCacheTTL(): number;
 export declare function getMaxCacheSizeBytes(): number;
 export declare function getMaxCloneCount(): number;
-export declare function createCacheMeta(owner: string, repo: string, branch: string, source: CacheSource, sparsePath?: string, sizeBytes?: number): CloneCacheMeta;
+export declare function createCacheMeta(owner: string, repo: string, branch: string, source: CacheSource, sparsePath?: string, sizeBytes?: number, commitSha?: string): CloneCacheMeta;
 export declare function ensureCloneParentDir(cloneDir: string): void;
 export declare function removeCloneDir(cloneDir: string): void;
 export declare function evictExpiredClones(octocodeDir: string): number;
+export declare function evictExpiredTrees(octocodeDir: string): number;
 export declare function startCacheGC(octocodeDir: string): void;
 export declare function stopCacheGC(): void;

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

@@ -10,8 +10,8 @@ export declare const CloneRepoQueryLocalSchema: import("zod").ZodObject<{
     reasoning: import("zod").ZodOptional<import("zod").ZodString>;
 }, import("zod/v4/core").$strip>;
 export declare const BulkCloneRepoLocalSchema: 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 GitHubCloneRepoOutputLocalSchema: import("zod").ZodObject<{
@@ -21,24 +21,71 @@ export declare const GitHubCloneRepoOutputLocalSchema: import("zod").ZodObject<{
     }>>;
     data: import("zod").ZodOptional<import("zod").ZodObject<{
         localPath: import("zod").ZodString;
-        branch: import("zod").ZodString;
-        cached: import("zod").ZodBoolean;
+        resolvedBranch: import("zod").ZodOptional<import("zod").ZodString>;
+        cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
         sparsePath: import("zod").ZodOptional<import("zod").ZodString>;
         cloneTimeMs: import("zod").ZodOptional<import("zod").ZodNumber>;
         totalSize: import("zod").ZodOptional<import("zod").ZodNumber>;
         fileCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+        location: import("zod").ZodOptional<import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<{
+                file: "file";
+                directory: "directory";
+                repo: "repo";
+                tree: "tree";
+                "archive-entry": "archive-entry";
+            }>;
+            localPath: import("zod").ZodString;
+            repoRoot: import("zod").ZodOptional<import("zod").ZodString>;
+            requestedPath: import("zod").ZodOptional<import("zod").ZodString>;
+            source: import("zod").ZodOptional<import("zod").ZodEnum<{
+                extract: "extract";
+                decompress: "decompress";
+                strings: "strings";
+                unpack: "unpack";
+                tree: "tree";
+                clone: "clone";
+            }>>;
+            cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            complete: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            resolvedBranch: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
     }, import("zod/v4/core").$strip>>;
     localPath: import("zod").ZodOptional<import("zod").ZodString>;
-    branch: import("zod").ZodOptional<import("zod").ZodString>;
+    resolvedBranch: import("zod").ZodOptional<import("zod").ZodString>;
     cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    sparsePath: import("zod").ZodOptional<import("zod").ZodString>;
+    location: import("zod").ZodOptional<import("zod").ZodObject<{
+        kind: import("zod").ZodEnum<{
+            file: "file";
+            directory: "directory";
+            repo: "repo";
+            tree: "tree";
+            "archive-entry": "archive-entry";
+        }>;
+        localPath: import("zod").ZodString;
+        repoRoot: import("zod").ZodOptional<import("zod").ZodString>;
+        requestedPath: import("zod").ZodOptional<import("zod").ZodString>;
+        source: import("zod").ZodOptional<import("zod").ZodEnum<{
+            extract: "extract";
+            decompress: "decompress";
+            strings: "strings";
+            unpack: "unpack";
+            tree: "tree";
+            clone: "clone";
+        }>>;
+        cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        complete: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        resolvedBranch: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
     warnings: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
         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/github_clone_repo/types.d.ts

@@ -1,10 +1,12 @@
-export type CacheSource = 'clone' | 'directoryFetch';
+export type CacheSource = 'clone' | 'directoryFetch' | 'treeFetch';
 export interface CloneCacheMeta {
     clonedAt: string;
     expiresAt: string;
     owner: string;
     repo: string;
     branch: string;
+    /** HEAD commit SHA at the time this entry was written. Absent on legacy entries. */
+    commitSha?: string;
     sparsePath?: string;
     source: CacheSource;
     sizeBytes?: number;

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

@@ -32,8 +32,8 @@ export declare const FileContentQueryLocalSchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const FileContentBulkQueryLocalSchema: 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 GitHubFetchContentOutputLocalSchema: z.ZodObject<{
@@ -55,6 +55,8 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
         files: z.ZodOptional<z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             content: z.ZodString;
+            localPath: z.ZodOptional<z.ZodString>;
+            repoRoot: z.ZodOptional<z.ZodString>;
             contentView: z.ZodOptional<z.ZodEnum<{
                 none: "none";
                 standard: "standard";
@@ -69,6 +71,8 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
                 currentPage: z.ZodNumber;
                 totalPages: z.ZodNumber;
                 hasMore: z.ZodBoolean;
+                nextPage: z.ZodOptional<z.ZodNumber>;
+                nextMatchPage: z.ZodOptional<z.ZodNumber>;
                 charOffset: z.ZodOptional<z.ZodNumber>;
                 charLength: z.ZodOptional<z.ZodNumber>;
                 totalChars: z.ZodOptional<z.ZodNumber>;
@@ -92,12 +96,34 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
             warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
             matchNotFound: z.ZodOptional<z.ZodBoolean>;
             searchedFor: z.ZodOptional<z.ZodString>;
+            cached: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>;
         directories: z.ZodOptional<z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             localPath: z.ZodString;
+            repoRoot: z.ZodOptional<z.ZodString>;
             fileCount: z.ZodNumber;
             totalSize: z.ZodNumber;
+            complete: z.ZodOptional<z.ZodBoolean>;
+            directoryEntryCount: z.ZodOptional<z.ZodNumber>;
+            eligibleFileCount: z.ZodOptional<z.ZodNumber>;
+            savedFileCount: z.ZodOptional<z.ZodNumber>;
+            skipped: z.ZodOptional<z.ZodObject<{
+                nonFile: z.ZodNumber;
+                missingDownloadUrl: z.ZodNumber;
+                oversized: z.ZodNumber;
+                binary: z.ZodNumber;
+                fileLimit: z.ZodNumber;
+                fetchFailed: z.ZodNumber;
+                totalSizeLimit: z.ZodNumber;
+                pathTraversal: z.ZodNumber;
+            }, z.core.$strip>>;
+            limits: z.ZodOptional<z.ZodObject<{
+                maxDirectoryFiles: z.ZodNumber;
+                maxTotalSize: z.ZodNumber;
+                maxFileSize: z.ZodNumber;
+            }, z.core.$strip>>;
+            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
             files: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 path: z.ZodString;
                 size: z.ZodNumber;
@@ -106,15 +132,97 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
             cached: z.ZodOptional<z.ZodBoolean>;
             resolvedBranch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        data: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            repo: z.ZodString;
+            files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+                localPath: z.ZodOptional<z.ZodString>;
+                repoRoot: z.ZodOptional<z.ZodString>;
+                contentView: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    standard: "standard";
+                    symbols: "symbols";
+                }>>;
+                isSkeleton: z.ZodOptional<z.ZodBoolean>;
+                totalLines: z.ZodOptional<z.ZodNumber>;
+                sourceChars: z.ZodOptional<z.ZodNumber>;
+                sourceBytes: z.ZodOptional<z.ZodNumber>;
+                resolvedBranch: z.ZodOptional<z.ZodString>;
+                pagination: z.ZodOptional<z.ZodObject<{
+                    currentPage: z.ZodNumber;
+                    totalPages: z.ZodNumber;
+                    hasMore: z.ZodBoolean;
+                    nextPage: z.ZodOptional<z.ZodNumber>;
+                    nextMatchPage: z.ZodOptional<z.ZodNumber>;
+                    charOffset: z.ZodOptional<z.ZodNumber>;
+                    charLength: z.ZodOptional<z.ZodNumber>;
+                    totalChars: z.ZodOptional<z.ZodNumber>;
+                    nextCharOffset: z.ZodOptional<z.ZodNumber>;
+                    filesPerPage: z.ZodOptional<z.ZodNumber>;
+                    totalFiles: z.ZodOptional<z.ZodNumber>;
+                    entriesPerPage: z.ZodOptional<z.ZodNumber>;
+                    totalEntries: z.ZodOptional<z.ZodNumber>;
+                    matchesPerPage: z.ZodOptional<z.ZodNumber>;
+                    totalMatches: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                isPartial: z.ZodOptional<z.ZodBoolean>;
+                startLine: z.ZodOptional<z.ZodNumber>;
+                endLine: z.ZodOptional<z.ZodNumber>;
+                matchRanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    start: z.ZodNumber;
+                    end: z.ZodNumber;
+                }, z.core.$strip>>>;
+                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>;
+                cached: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            directories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                localPath: z.ZodString;
+                repoRoot: z.ZodOptional<z.ZodString>;
+                fileCount: z.ZodNumber;
+                totalSize: z.ZodNumber;
+                complete: z.ZodOptional<z.ZodBoolean>;
+                directoryEntryCount: z.ZodOptional<z.ZodNumber>;
+                eligibleFileCount: z.ZodOptional<z.ZodNumber>;
+                savedFileCount: z.ZodOptional<z.ZodNumber>;
+                skipped: z.ZodOptional<z.ZodObject<{
+                    nonFile: z.ZodNumber;
+                    missingDownloadUrl: z.ZodNumber;
+                    oversized: z.ZodNumber;
+                    binary: z.ZodNumber;
+                    fileLimit: z.ZodNumber;
+                    fetchFailed: z.ZodNumber;
+                    totalSizeLimit: z.ZodNumber;
+                    pathTraversal: z.ZodNumber;
+                }, z.core.$strip>>;
+                limits: z.ZodOptional<z.ZodObject<{
+                    maxDirectoryFiles: z.ZodNumber;
+                    maxTotalSize: z.ZodNumber;
+                    maxFileSize: z.ZodNumber;
+                }, z.core.$strip>>;
+                warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    size: z.ZodNumber;
+                    type: z.ZodString;
+                }, z.core.$strip>>>;
+                cached: z.ZodOptional<z.ZodBoolean>;
+                resolvedBranch: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
-    hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         owner: z.ZodOptional<z.ZodString>;
         repo: z.ZodOptional<z.ZodString>;
         path: z.ZodOptional<z.ZodString>;
         error: z.ZodString;
-        hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type GitHubFetchContentOutputLocal = z.infer<typeof GitHubFetchContentOutputLocalSchema>;

package/dist/tools/github_fetch_content/types.d.ts

@@ -49,6 +49,7 @@ export interface GitHubFileContentApiResult extends GitHubFileContentApiResultBa
 }
 export interface DirectoryFetchResult {
     localPath: string;
+    repoRoot: string;
     files: Array<{
         path: string;
         size: number;
@@ -56,6 +57,33 @@ export interface DirectoryFetchResult {
     }>;
     fileCount: number;
     totalSize: number;
+    /** true = no files were skipped by size/type/limit/error */
+    complete: boolean;
+    /** true = completeness was proven against the remote tree (fresh fetch + complete) */
+    verified: boolean;
+    /** HEAD commit SHA at the time of fetch; absent on cache hits from legacy entries */
+    commitSha?: string;
+    /** true when nonFile > 0 — subdirectory entries were present but not fetched; use ghCloneRepo for full coverage */
+    hasSubdirectories?: boolean;
+    directoryEntryCount: number;
+    eligibleFileCount: number;
+    savedFileCount: number;
+    skipped: {
+        nonFile: number;
+        missingDownloadUrl: number;
+        oversized: number;
+        binary: number;
+        fileLimit: number;
+        fetchFailed: number;
+        totalSizeLimit: number;
+        pathTraversal: number;
+    };
+    limits: {
+        maxDirectoryFiles: number;
+        maxTotalSize: number;
+        maxFileSize: number;
+    };
+    warnings?: string[];
     cached: boolean;
     expiresAt: string;
     owner: string;
@@ -63,4 +91,15 @@ export interface DirectoryFetchResult {
     branch: string;
     directoryPath: string;
 }
+export interface FileMaterializationResult {
+    localPath: string;
+    repoRoot: string;
+    path: string;
+    size: number;
+    cached: boolean;
+    expiresAt: string;
+    owner: string;
+    repo: string;
+    branch: string;
+}
 export {};

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

@@ -20,8 +20,8 @@ export declare const GitHubCodeSearchQueryLocalSchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const GitHubCodeSearchBulkQueryLocalSchema: 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 GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
@@ -40,7 +40,6 @@ export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
         id: z.ZodString;
         data: z.ZodObject<{
             files: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
                 owner: z.ZodString;
                 repo: z.ZodString;
                 path: z.ZodString;
@@ -51,6 +50,7 @@ export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
                     matchIndices: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         start: z.ZodNumber;
                         end: z.ZodNumber;
+                        lineOffset: z.ZodNumber;
                     }, z.core.$strip>>>;
                     url: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
@@ -69,20 +69,20 @@ export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
                 }>>;
                 totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
                 hasMore: z.ZodBoolean;
+                nextPage: z.ZodOptional<z.ZodNumber>;
                 uniqueFileCount: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>;
     }, z.core.$strip>>;
-    hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     emptyQueries: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
         nonExistentScope: z.ZodOptional<z.ZodLiteral<true>>;
+        incompleteResults: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
     errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         error: z.ZodString;
-        hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type GitHubCodeSearchOutputLocal = z.infer<typeof GitHubCodeSearchOutputLocalSchema>;

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

@@ -14,5 +14,4 @@ type QueryLike = {
     matchString?: string;
 };
 export declare function shapePullRequestForContent(pr: Record<string, unknown>, query: QueryLike, request: NormalizedPrContentRequest, shouldMinify?: boolean, showContentMap?: boolean): Record<string, unknown>;
-export declare function buildContentHints(pullRequests: Array<Record<string, unknown>>, request: NormalizedPrContentRequest): string[];
 export {};

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

@@ -1,17 +1,7 @@
 import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import type { z } from 'zod';
 import { GitHubPullRequestSearchQueryLocalSchema } from './scheme.js';
-type GitHubPullRequestSearchQuery = z.infer<typeof GitHubPullRequestSearchQueryLocalSchema>;
-import type { ToolExecutionArgs, WithOptionalMeta } from '../../types/execution.js';
+import type { ToolExecutionArgs } from '../../types/execution.js';
 type GitHubPullRequestSearchInput = z.input<typeof GitHubPullRequestSearchQueryLocalSchema>;
-type PartialPRQuery = WithOptionalMeta<GitHubPullRequestSearchQuery>;
 export declare function searchMultipleGitHubPullRequests(args: ToolExecutionArgs<GitHubPullRequestSearchInput>): Promise<CallToolResult>;
-export declare function buildPRSearchOutput(input: {
-    data: Record<string, unknown>;
-    pullRequests: Array<Record<string, unknown>>;
-    extraHints: string[];
-}, _query: PartialPRQuery): {
-    data: Record<string, unknown>;
-    extraHints: string[];
-};
 export {};

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>;