@octocodeai/octocode-tools-core 16.2.0

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

@@ -0,0 +1,21 @@
+import type { CloneCacheMeta, CacheSource } from './types.js';
+export declare function getReposBaseDir(octocodeDir: string): string;
+export declare function getCloneDir(octocodeDir: string, owner: string, repo: string, branch: string, sparsePath?: 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;
+export declare function isCacheHit(cloneDir: string): {
+    hit: true;
+    meta: CloneCacheMeta;
+} | {
+    hit: false;
+};
+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 ensureCloneParentDir(cloneDir: string): void;
+export declare function removeCloneDir(cloneDir: string): void;
+export declare function evictExpiredClones(octocodeDir: string): number;
+export declare function startCacheGC(octocodeDir: string): void;
+export declare function stopCacheGC(): void;

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

@@ -0,0 +1,6 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { WithOptionalMeta } from '../../types/execution.js';
+import type { CloneRepoQueryLocalSchema } from './scheme.js';
+import type { z } from 'zod';
+import type { CloneRepoResult } from './types.js';
+export declare function cloneRepo(query: WithOptionalMeta<z.infer<typeof CloneRepoQueryLocalSchema>>, authInfo?: AuthInfo, token?: string): Promise<CloneRepoResult>;

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

@@ -0,0 +1,8 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolExecutionArgs, WithOptionalMeta } from '../../types/execution.js';
+type PartialCloneRepoQuery = WithOptionalMeta<CloneRepoQuery>;
+import type { CloneRepoQueryLocalSchema } from './scheme.js';
+import type { z } from 'zod';
+type CloneRepoQuery = z.infer<typeof CloneRepoQueryLocalSchema>;
+export declare function executeCloneRepo(args: ToolExecutionArgs<PartialCloneRepoQuery>): Promise<CallToolResult>;
+export {};

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

@@ -0,0 +1,2 @@
+import type { ToolHintGenerators } from '../../types/metadata.js';
+export declare const hints: ToolHintGenerators;

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

@@ -0,0 +1,50 @@
+export declare const CloneRepoQueryLocalSchema: import("zod").ZodObject<{
+    owner: import("zod").ZodString;
+    repo: import("zod").ZodString;
+    branch: import("zod").ZodOptional<import("zod").ZodString>;
+    sparsePath: import("zod").ZodOptional<import("zod").ZodString>;
+    forceRefresh: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    id: import("zod").ZodOptional<import("zod").ZodString>;
+    mainResearchGoal: import("zod").ZodOptional<import("zod").ZodString>;
+    researchGoal: import("zod").ZodOptional<import("zod").ZodString>;
+    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>>;
+    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<{
+    status: import("zod").ZodOptional<import("zod").ZodEnum<{
+        empty: import("@octocodeai/octocode-core/types").ToolStatus.Empty;
+        error: import("@octocodeai/octocode-core/types").ToolStatus.Error;
+    }>>;
+    data: import("zod").ZodOptional<import("zod").ZodObject<{
+        localPath: import("zod").ZodString;
+        branch: import("zod").ZodString;
+        cached: 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>;
+    }, import("zod/v4/core").$strip>>;
+    localPath: import("zod").ZodOptional<import("zod").ZodString>;
+    branch: import("zod").ZodOptional<import("zod").ZodString>;
+    cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    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<{
+        currentPage: import("zod").ZodNumber;
+        totalPages: import("zod").ZodNumber;
+        hasMore: import("zod").ZodBoolean;
+        charOffset: import("zod").ZodNumber;
+        charLength: import("zod").ZodNumber;
+        totalChars: import("zod").ZodNumber;
+        nextCharOffset: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$loose>;

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

@@ -0,0 +1,19 @@
+export type CacheSource = 'clone' | 'directoryFetch';
+export interface CloneCacheMeta {
+    clonedAt: string;
+    expiresAt: string;
+    owner: string;
+    repo: string;
+    branch: string;
+    sparsePath?: string;
+    source: CacheSource;
+    sizeBytes?: number;
+}
+export interface CloneRepoResult {
+    localPath: string;
+    cached: boolean;
+    owner: string;
+    repo: string;
+    branch: string;
+    sparsePath?: string;
+}

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

@@ -0,0 +1,7 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { z } from 'zod';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+import { FileContentQueryLocalSchema } from './scheme.js';
+type FileContentInputQuery = z.input<typeof FileContentQueryLocalSchema>;
+export declare function fetchMultipleGitHubFileContents(args: ToolExecutionArgs<FileContentInputQuery>): Promise<CallToolResult>;
+export {};

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

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import type { FileContentQuerySchema } from '@octocodeai/octocode-core/schemas';
+type FileContentQuery = z.infer<typeof FileContentQuerySchema>;
+import type { BulkFinalizer } from '../../types/bulk.js';
+import { type QueryWithPagination } from '../../utils/response/groupedFinalizer.js';
+import type { GitHubFetchContentOutputLocal } from './scheme.js';
+import type { WithOptionalMeta } from '../../types/execution.js';
+type PartialFileContentQuery = WithOptionalMeta<FileContentQuery> & QueryWithPagination;
+export declare function buildGithubFetchContentFinalizer<TQuery extends PartialFileContentQuery>(): BulkFinalizer<TQuery, GitHubFetchContentOutputLocal>;
+export {};

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

@@ -0,0 +1,2 @@
+import type { ToolHintGenerators } from '../../types/metadata.js';
+export declare const hints: ToolHintGenerators;

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

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+export declare const FileContentQueryBaseLocalSchema: z.ZodObject<Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z.core.$strip>;
+export declare const FileContentQueryLocalSchema: z.ZodObject<{
+    owner: z.ZodString;
+    repo: z.ZodString;
+    branch: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    startLine: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    fullContent: z.ZodOptional<z.ZodBoolean>;
+    matchString: z.ZodOptional<z.ZodString>;
+    matchStringIsRegex: z.ZodOptional<z.ZodBoolean>;
+    matchStringCaseSensitive: z.ZodOptional<z.ZodBoolean>;
+    forceRefresh: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodDefault<z.ZodEnum<{
+        file: "file";
+        directory: "directory";
+    }>>;
+    contextLines: z.ZodDefault<z.ZodNumber>;
+    charOffset: z.ZodOptional<z.ZodNumber>;
+    charLength: z.ZodOptional<z.ZodNumber>;
+    minify: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        standard: "standard";
+        symbols: "symbols";
+    }>>;
+    id: z.ZodOptional<z.ZodString>;
+    mainResearchGoal: z.ZodOptional<z.ZodString>;
+    researchGoal: z.ZodOptional<z.ZodString>;
+    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>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;
+export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
+    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>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        owner: z.ZodString;
+        repo: z.ZodString;
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: 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;
+                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>;
+        }, z.core.$strip>>>;
+        directories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            localPath: z.ZodString;
+            fileCount: z.ZodNumber;
+            totalSize: z.ZodNumber;
+            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>>;
+    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

@@ -0,0 +1,66 @@
+import type { z } from 'zod';
+import type { FileContentQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { MinifyMode } from '../../scheme/fields.js';
+type FileContentQuery = z.infer<typeof FileContentQuerySchema>;
+import type { PaginationInfo } from '../../utils/core/types.js';
+export type FileContentExecutionQuery = FileContentQuery & {
+    noTimestamp?: boolean;
+    minify: MinifyMode;
+    contextLines?: number;
+    matchStringIsRegex?: boolean;
+    matchStringCaseSensitive?: boolean;
+    charOffset?: number;
+    charLength?: number;
+};
+export interface GitHubFileContentApiData {
+    owner?: string;
+    repo?: string;
+    path?: string;
+    content?: string;
+    contentView?: 'none' | 'standard' | 'symbols';
+    isSkeleton?: boolean;
+    branch?: string;
+    resolvedBranch?: string;
+    startLine?: number;
+    endLine?: number;
+    isPartial?: boolean;
+    totalLines?: number;
+    sourceChars?: number;
+    sourceBytes?: number;
+    matchRanges?: Array<{
+        start: number;
+        end: number;
+    }>;
+    matchLocations?: string[];
+    warnings?: string[];
+    lastModified?: string;
+    lastModifiedBy?: string;
+    pagination?: PaginationInfo;
+    cached?: boolean;
+    matchNotFound?: boolean;
+    searchedFor?: string;
+    signaturesExtracted?: boolean;
+}
+interface GitHubFileContentApiResultBase {
+    error?: string;
+    hints?: string[];
+}
+export interface GitHubFileContentApiResult extends GitHubFileContentApiResultBase, GitHubFileContentApiData {
+}
+export interface DirectoryFetchResult {
+    localPath: string;
+    files: Array<{
+        path: string;
+        size: number;
+        type: string;
+    }>;
+    fileCount: number;
+    totalSize: number;
+    cached: boolean;
+    expiresAt: string;
+    owner: string;
+    repo: string;
+    branch: string;
+    directoryPath: string;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { z } from 'zod';
+import type { GitHubCodeSearchQuerySchema } from '@octocodeai/octocode-core/schemas';
+type GitHubCodeSearchQuery = z.infer<typeof GitHubCodeSearchQuerySchema>;
+import type { ToolExecutionArgs, WithOptionalMeta } from '../../types/execution.js';
+type PartialCodeSearchQuery = WithOptionalMeta<GitHubCodeSearchQuery>;
+export declare function searchMultipleGitHubCode(args: ToolExecutionArgs<PartialCodeSearchQuery>): Promise<CallToolResult>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { BulkFinalizer } from '../../types/bulk.js';
+import { type QueryWithPagination } from '../../utils/response/groupedFinalizer.js';
+import type { GitHubCodeSearchOutputLocal } from './scheme.js';
+import { type CodeSearchGroupedResult } from '../providerMappers.js';
+export declare function applyExactMatchRanking(groups: readonly CodeSearchGroupedResult[], keywords: readonly string[]): CodeSearchGroupedResult[];
+export declare function buildGhSearchCodeFinalizer<TQuery extends QueryWithPagination>(): BulkFinalizer<TQuery, GitHubCodeSearchOutputLocal>;

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

@@ -0,0 +1,2 @@
+import type { ToolHintGenerators } from '../../types/metadata.js';
+export declare const hints: ToolHintGenerators;

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

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export declare const GitHubCodeSearchQueryLocalSchema: z.ZodObject<{
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    extension: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    match: z.ZodDefault<z.ZodEnum<{
+        file: "file";
+        path: "path";
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    page: z.ZodDefault<z.ZodNumber>;
+    concise: z.ZodOptional<z.ZodBoolean>;
+    id: z.ZodOptional<z.ZodString>;
+    mainResearchGoal: z.ZodOptional<z.ZodString>;
+    researchGoal: z.ZodOptional<z.ZodString>;
+    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>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;
+export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
+    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>>;
+    results: z.ZodArray<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;
+                queryId: z.ZodOptional<z.ZodString>;
+                matches: z.ZodArray<z.ZodObject<{
+                    value: z.ZodOptional<z.ZodString>;
+                    pathOnly: z.ZodOptional<z.ZodBoolean>;
+                    matchIndices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        start: z.ZodNumber;
+                        end: z.ZodNumber;
+                    }, z.core.$strip>>>;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            pagination: z.ZodOptional<z.ZodObject<{
+                currentPage: z.ZodNumber;
+                totalPages: z.ZodNumber;
+                perPage: z.ZodNumber;
+                totalMatches: 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>;
+                hasMore: z.ZodBoolean;
+                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>>;
+    }, z.core.$strip>>>;
+    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/contentRequest.d.ts

@@ -0,0 +1,52 @@
+export type PartialContentRange = {
+    file: string;
+    additions?: number[];
+    deletions?: number[];
+};
+export type PrContentSelector = {
+    body?: boolean;
+    changedFiles?: boolean;
+    patches?: {
+        mode?: 'none' | 'selected' | 'all';
+        files?: string[];
+        ranges?: PartialContentRange[];
+    };
+    comments?: {
+        discussion?: boolean;
+        reviewInline?: boolean;
+        includeBots?: boolean;
+        file?: string;
+    };
+    reviews?: boolean;
+    commits?: {
+        list?: boolean;
+        includeFiles?: boolean;
+    };
+};
+export type PullRequestContentQuery = {
+    content?: PrContentSelector;
+    reviewMode?: 'full';
+};
+export type NormalizedPrContentRequest = {
+    body: boolean;
+    changedFiles: boolean;
+    patches: {
+        mode: 'none' | 'selected' | 'all';
+        files?: string[];
+        ranges?: PartialContentRange[];
+    };
+    comments: false | {
+        discussion: boolean;
+        reviewInline: boolean;
+        includeBots: boolean;
+        file?: string;
+    };
+    reviews: boolean;
+    commits: false | {
+        list: boolean;
+        includeFiles: boolean;
+    };
+    reviewMode?: 'full';
+};
+export declare function normalizePullRequestContentRequest(query: PullRequestContentQuery): NormalizedPrContentRequest;
+export declare function hasExpensiveContentRequest(request: NormalizedPrContentRequest): boolean;

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

@@ -0,0 +1,18 @@
+import type { NormalizedPrContentRequest } from './contentRequest.js';
+type QueryLike = {
+    owner?: string;
+    repo?: string;
+    prNumber?: number;
+    page?: number;
+    filePage?: number;
+    commentPage?: number;
+    commitPage?: number;
+    itemsPerPage?: number;
+    charOffset?: number;
+    commentBodyOffset?: number;
+    charLength?: number;
+    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

@@ -0,0 +1,17 @@
+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';
+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/hints.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHintGenerators } from '../../types/metadata.js';
+export declare const hints: ToolHintGenerators;