@octocodeai/octocode-tools-core 18.3.0 → 19.1.0

package/dist/github/canonicalRepo.d.ts

@@ -1,3 +1,4 @@
+import type { AuthInfo } from '@modelcontextprotocol/server';
 import { OctokitWithThrottling } from './client.js';
 /**
  * Resolve an owner/repo to its canonical name, following GitHub repository
@@ -7,7 +8,7 @@ import { OctokitWithThrottling } from './client.js';
  * is authoritative. Returns the original pair on any failure (network, 404,
  * private) so callers degrade gracefully rather than blocking the search.
  */
-export declare function resolveCanonicalOwnerRepo(octokit: InstanceType<typeof OctokitWithThrottling>, owner: string, repo: string): Promise<{
+export declare function resolveCanonicalOwnerRepo(octokit: InstanceType<typeof OctokitWithThrottling>, owner: string, repo: string, authInfo?: AuthInfo): Promise<{
     owner: string;
     repo: string;
     renamed: boolean;

package/dist/github/client.d.ts

@@ -1,17 +1,12 @@
+import { Octokit } from 'octokit';
 import type { AuthInfo } from '@modelcontextprotocol/server';
 export declare function hashGitHubToken(token: string): string;
 /**
  * Auth segment for GitHub API cache keys. Distinct tokens (and Enterprise
- * hosts) must not share cache entries. Never puts the raw token in the key.
+ * endpoints) must not share cache entries. Never puts the raw token in the key.
  */
 export declare function resolveCacheAuthFingerprint(authInfo?: AuthInfo): Promise<string>;
-export declare const OctokitWithThrottling: typeof import("@octokit/core").Octokit & import("@octokit/core/types").Constructor<{
-    paginate: import("@octokit/plugin-paginate-rest").PaginateInterface;
-} & import("@octokit/plugin-paginate-graphql").paginateGraphQLInterface & import("@octokit/plugin-rest-endpoint-methods").Api & {
-    retry: {
-        retryRequest: (error: import("octokit").RequestError, retries: number, retryAfter: number) => import("octokit").RequestError;
-    };
-}> & import("@octokit/core/types").Constructor<{}>;
+export declare const OctokitWithThrottling: typeof Octokit;
 export declare function getOctokit(authInfo?: AuthInfo): Promise<InstanceType<typeof OctokitWithThrottling>>;
 export declare const MAX_BRANCH_CACHE_SIZE = 200;
 export declare function resolveDefaultBranch(owner: string, repo: string, authInfo?: AuthInfo): Promise<string>;

package/dist/github/codeSearch/compactFragment.d.ts

@@ -0,0 +1,7 @@
+/** Compact discovery context only when every match surviving redaction remains. */
+export declare function compactMatchedFragment(raw: string, sanitized: string, rawPositions: [number, number][], path: string): Promise<{
+    context: string;
+    positions: [number, number][];
+    minificationType?: string;
+    failed?: boolean;
+}>;

package/dist/github/codeSearch.d.ts

@@ -1,9 +1,8 @@
 import type { GitHubAPIResponse, OptimizedCodeSearchResult } from './githubAPI.js';
 import type { z } from 'zod';
-import type { GitHubCodeSearchQuerySchema } from '../toolContract/schemas.js';
+import type { GitHubCodeSearchQuerySchema } from '../toolContract/input/resources/tools/githubCodeOperation.js';
 type GitHubCodeSearchQuery = z.infer<typeof GitHubCodeSearchQuerySchema>;
 import type { WithOptionalMeta } from '../types/execution.js';
 import { AuthInfo } from '@modelcontextprotocol/server';
-import { recomputeMatchPositions } from './codeSearch/matchPositions.js';
-export { recomputeMatchPositions };
 export declare function searchGitHubCodeAPI(params: WithOptionalMeta<GitHubCodeSearchQuery>, authInfo?: AuthInfo, sessionId?: string): Promise<GitHubAPIResponse<OptimizedCodeSearchResult>>;
+export {};

package/dist/github/commit.d.ts

@@ -24,6 +24,13 @@ export interface ExactCommitResult {
     additions?: number;
     deletions?: number;
     changedFiles: number;
+    isPartial?: boolean;
+    terminalLimit?: boolean;
+    partialReasons?: string[];
+    providerLimit?: {
+        reason: string;
+        maxFiles: number;
+    };
     files?: HistoryCommitFile[];
     filesPagination?: {
         currentPage: number;
@@ -42,6 +49,7 @@ export declare function fetchCommit(params: {
     includeDiff?: boolean;
     path?: string;
     filePage?: number;
+    fileBatch?: number;
     itemsPerPage?: number;
     charOffset?: number;
     charLength?: number;

package/dist/github/commitDetail.d.ts

@@ -0,0 +1,20 @@
+import type { AuthInfo } from '@modelcontextprotocol/server';
+import { getOctokit } from './client.js';
+export declare const COMMIT_FILE_LIMIT = 3000;
+type CommitData = Awaited<ReturnType<Awaited<ReturnType<typeof getOctokit>>['rest']['repos']['getCommit']>>['data'];
+/** Fetch one auth-scoped provider batch; callers expose independent file and batch continuations. */
+export declare function fetchCommitDetail(params: {
+    owner: string;
+    repo: string;
+    ref: string;
+    fileBatch?: number;
+}, authInfo?: AuthInfo): Promise<{
+    data: CommitData;
+    collectionState: {
+        page: number;
+        hasMore: boolean;
+    };
+    terminalLimit: boolean;
+    rawResponseChars: number;
+}>;
+export {};

package/dist/github/commitSearch.d.ts

@@ -0,0 +1,17 @@
+import type { AuthInfo } from '@modelcontextprotocol/server';
+import type { GitHubAPIResponse } from './githubAPI.js';
+interface CommitSearchParams {
+    owner: string;
+    repo: string;
+    keywords: string[];
+    author?: string;
+    committer?: string;
+    since?: string;
+    until?: string;
+    page: number;
+    perPage: number;
+}
+export declare function searchCommits(params: CommitSearchParams, authInfo?: AuthInfo): Promise<GitHubAPIResponse<Record<string, unknown> & {
+    commits: Array<Record<string, unknown>>;
+}>>;
+export {};

package/dist/github/compare.d.ts

@@ -11,6 +11,20 @@ export type CompareResult = {
     aheadBy: number;
     behindBy: number;
     totalCommits: number;
+    pagination?: {
+        currentPage: number;
+        perPage: number;
+        hasMore: boolean;
+        nextPage?: number;
+    };
+    isPartial?: boolean;
+    terminalLimit?: boolean;
+    partialReasons?: string[];
+    providerLimit?: {
+        reason: string;
+        maxFiles?: number;
+        maxPage?: number;
+    };
     commits: Array<{
         sha: string;
         messageHeadline: string;
@@ -42,6 +56,7 @@ export declare function compareRefs(params: {
     base: string;
     head: string;
     includeDiff?: boolean;
+    page?: number;
     /** Restrict the diff to a single file path (searchable scope). */
     path?: string;
     filePage?: number;

package/dist/github/directoryFetch/cacheMetadata.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const DIRECTORY_META_FILE = ".octocode-directory-meta.json";
+declare const directoryCacheSchema: z.ZodObject<{
+    commitSha: z.ZodString;
+    complete: z.ZodBoolean;
+    directoryEntryCount: z.ZodNumber;
+    eligibleFileCount: z.ZodNumber;
+    skipped: z.ZodObject<{
+        nonFile: z.ZodNumber;
+        oversized: z.ZodNumber;
+        binary: z.ZodNumber;
+        fileLimit: z.ZodNumber;
+        fetchFailed: z.ZodNumber;
+        totalSizeLimit: z.ZodNumber;
+        pathTraversal: z.ZodNumber;
+    }, z.core.$strip>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type DirectoryCacheMetadata = z.infer<typeof directoryCacheSchema>;
+export declare function readDirectoryCacheMetadata(dirPath: string, commitSha: string): DirectoryCacheMetadata | undefined;
+export declare function writeDirectoryCacheMetadata(dirPath: string, metadata: DirectoryCacheMetadata): void;
+export {};

package/dist/github/directoryFetch/helpers.d.ts

@@ -4,7 +4,6 @@ export declare const MAX_DIRECTORY_FILES = 50;
 export declare const MAX_TOTAL_SIZE: number;
 export declare const MAX_FILE_SIZE: number;
 export declare const CONCURRENCY = 5;
-export declare const FETCH_TIMEOUT_MS = 10000;
 export declare const BINARY_EXTENSIONS: Set<string>;
 export interface DirectoryEntry {
     name: string;
@@ -22,11 +21,10 @@ export declare const DIRECTORY_FETCH_LIMITS: {
 export declare function emptyDirectorySkipCounts(): DirectorySkipCounts;
 export declare function directoryFetchComplete(skipped: DirectorySkipCounts): boolean;
 export declare function directoryFetchWarnings(complete: boolean, verified: boolean): string[] | undefined;
-export declare function fetchFilesInBatches(entries: DirectoryEntry[], concurrency: number, token?: string): Promise<Array<{
+export declare function fetchFilesInBatches(entries: DirectoryEntry[], concurrency: number, fetchContent: (entry: DirectoryEntry) => Promise<string>): Promise<Array<{
     entry: DirectoryEntry;
     content: string;
 }>>;
-export declare function fetchDownloadUrl(url: string, token?: string): Promise<string>;
 export declare function scanDirectoryStats(dirPath: string, repoRoot: string): {
     files: GitHubDirectoryFileEntry[];
     fileCount: number;

package/dist/github/directoryFetch/snapshot.d.ts

@@ -0,0 +1,10 @@
+import type { CloneCacheMeta } from '../../tools/github_clone_repo/types.js';
+/** Serializes overlapping file/directory updates across CLI and MCP processes. */
+export declare function withTreeLock<T>(home: string, cacheRoot: string, run: () => Promise<T>): Promise<T>;
+export declare function ensureSnapshotDirectory(root: string, relativePath: string): string;
+export declare function currentTreeSnapshot(cacheRoot: string): string | undefined;
+/** Publish a fully written immutable generation by atomically replacing its metadata pointer.
+ * Existing callers retain their generation; a failed update cannot remove their files.
+ * Call under withTreeLock. Whole-cache TTL/capacity eviction owns old generations.
+ */
+export declare function publishTreeSnapshot(home: string, cacheRoot: string, previousRoot: string | undefined, meta: CloneCacheMeta, write: (root: string) => void): string;

package/dist/github/fileContentProcess.d.ts

@@ -1,4 +1,3 @@
 import type { GitHubFileContentApiResult } from '../tools/github_fetch_content/types.js';
 import type { MinifyMode } from '../scheme/fields.js';
-export { applyContentPagination, fetchFileTimestamp, } from './fileContentPagination.js';
 export declare function processFileContentAPI(decodedContent: string, owner: string, repo: string, branch: string, filePath: string, fullContent: boolean, startLine?: number, endLine?: number, contextLines?: number, matchString?: string, matchStringIsRegex?: boolean, matchStringCaseSensitive?: boolean, minify?: MinifyMode): Promise<GitHubFileContentApiResult>;

package/dist/github/fileContentRaw/cache.d.ts

@@ -0,0 +1,9 @@
+import type { AuthInfo } from '@modelcontextprotocol/server';
+import type { FileContentExecutionQuery } from '../../tools/github_fetch_content/types.js';
+import type { GitHubAPIResponse } from '../githubAPI.js';
+import { type RawContentResult } from './fetch.js';
+/** Share one authenticated, ref-scoped raw response between reads and materialization. */
+export declare function fetchCachedRawGitHubFileContent(params: FileContentExecutionQuery, authInfo?: AuthInfo, sessionId?: string): Promise<{
+    rawResult: GitHubAPIResponse<RawContentResult>;
+    auth: string;
+}>;

package/dist/github/fileContentRaw/fetch.d.ts

@@ -1,6 +1,6 @@
 import type { GitHubAPIResponse } from '../githubAPI.js';
 import type { z } from 'zod';
-import type { FileContentQuerySchema } from '../../toolContract/schemas.js';
+import type { FileContentQuerySchema } from '../../toolContract/input/resources/tools/ghGetFileContent.js';
 type FileContentQuery = z.infer<typeof FileContentQuerySchema>;
 import { AuthInfo } from '@modelcontextprotocol/server';
 export interface RawContentResult {

package/dist/github/githubAPI.d.ts

@@ -1,3 +1,4 @@
+import type { CollectionPages, CollectionStates } from './prContentFetcher/collectionPaging.js';
 import type { components } from '@octokit/openapi-types';
 import type { RestEndpointMethodTypes } from '@octokit/plugin-rest-endpoint-methods';
 import type { DiffPreview } from '../utils/parsers/diff.js';
@@ -7,8 +8,8 @@ export type CodeSearchResultItem = components['schemas']['code-search-result-ite
 export type RepoSearchResultItem = components['schemas']['repo-search-result-item'];
 export type IssueSearchResultItem = components['schemas']['issue-search-result-item'];
 export type DiffEntry = components['schemas']['diff-entry'];
-export type PullRequestItem = components['schemas']['pull-request'];
-export type PullRequestSimple = components['schemas']['pull-request-simple'];
+export type PullRequestItem = RestEndpointMethodTypes['pulls']['get']['response']['data'];
+export type PullRequestSimple = RestEndpointMethodTypes['pulls']['list']['response']['data'][number];
 export type IssueComment = components['schemas']['issue-comment'];
 export interface PRReviewInfo {
     id: string;
@@ -32,6 +33,7 @@ export interface CommitInfo {
     author: string;
     date: string;
     files: CommitFileInfo[];
+    filesCollectionState?: import('./prContentFetcher/collectionPaging.js').CollectionState;
 }
 export interface HistoryCommitFile {
     filename: string;
@@ -39,6 +41,11 @@ export interface HistoryCommitFile {
     additions: number;
     deletions: number;
     patch?: string;
+    isPartial?: true;
+    terminalLimit?: true;
+    patchUnavailable?: {
+        reason: 'providerOmittedPatch';
+    };
     patchPagination?: {
         charOffset: number;
         charLength: number;
@@ -191,6 +198,12 @@ export interface PRCommentItem {
     line?: number;
     inReplyToId?: number | null;
 }
+export interface PRProviderLimit {
+    reason: 'providerResultCap';
+    surface: 'commits' | 'changedFiles' | 'commitFiles';
+    maxResults: number;
+    sha?: string;
+}
 export type GitHubPullRequestItem = Pick<IssueSearchResultItem, 'number' | 'title' | 'body' | 'state' | 'created_at' | 'updated_at' | 'closed_at' | 'url' | 'draft'> & {
     author: string;
     labels: string[];
@@ -210,6 +223,8 @@ export type GitHubPullRequestItem = Pick<IssueSearchResultItem, 'number' | 'titl
     };
     commits?: CommitInfo[];
     reviews?: PRReviewInfo[];
+    collectionStates?: CollectionStates;
+    providerLimits?: PRProviderLimit[];
     _sanitization_warnings?: string[];
 };
 export interface GitHubPullRequestsSearchParams {
@@ -257,6 +272,8 @@ export interface GitHubPullRequestsSearchParams {
     filePage?: number;
     commentPage?: number;
     commitPage?: number;
+    reviewPage?: number;
+    collectionPages?: CollectionPages;
     itemsPerPage?: number;
 }
 export declare function isGitHubAPIError(obj: unknown): obj is GitHubAPIError;

package/dist/github/history/commitFiles.d.ts

@@ -1,4 +1,16 @@
 import type { HistoryCommitFile } from '../githubAPI.js';
+/** A missing provider patch does not establish whether a file is binary or too large. */
+export declare function patchAvailability(patch: unknown): {
+    isPartial?: undefined;
+    terminalLimit?: undefined;
+    patchUnavailable?: undefined;
+} | {
+    isPartial: true;
+    terminalLimit: true;
+    patchUnavailable: {
+        reason: "providerOmittedPatch";
+    };
+};
 export declare function windowPatch(patch: string | undefined, charOffset: number | undefined, charLength: number | undefined): {
     patch: string;
     patchPagination?: {

package/dist/github/issues/fetchers.d.ts

@@ -1,6 +1,6 @@
 import type { AuthInfo } from '@modelcontextprotocol/server';
 import type { GitHubAPIResponse } from '../githubAPI.js';
-import { type IssueSearchParams } from '../queryBuilders.js';
+import { type IssueSearchParams } from '../queryBuilders/issues.js';
 import type { FetchIssuesParams, IssuesResult } from './types.js';
 export declare function fetchIssueByNumber(params: FetchIssuesParams, authInfo?: AuthInfo): Promise<GitHubAPIResponse<IssuesResult>>;
 export declare function searchIssues(searchParams: IssueSearchParams, params: FetchIssuesParams, authInfo?: AuthInfo): Promise<GitHubAPIResponse<IssuesResult>>;

package/dist/github/issues/types.d.ts

@@ -1,8 +1,9 @@
-import type { IssueSearchParams } from '../queryBuilders.js';
+import type { IssueSearchParams } from '../queryBuilders/issues.js';
 export type IssueCommentRow = {
     id: string;
     user: string;
     body: string;
+    bodyPagination?: NonNullable<IssueRow['contentPagination']>['body'];
     createdAt: string;
     updatedAt: string;
     commentType: 'discussion';
@@ -19,6 +20,7 @@ export type IssueRow = {
     body?: string;
     comments?: IssueCommentRow[];
     contentPagination?: {
+        commentBody?: NonNullable<IssueRow['contentPagination']>['body'];
         body?: {
             charOffset: number;
             charLength: number;

package/dist/github/prContentFetcher/collectionPaging.d.ts

@@ -0,0 +1,27 @@
+import type { AuthInfo } from '@modelcontextprotocol/server';
+export type CollectionSurface = 'changedFiles' | 'discussion' | 'inline' | 'reviews' | 'commits';
+export type CollectionPages = Partial<Record<CollectionSurface, number>>;
+export type CollectionState = {
+    page: number;
+    hasMore: boolean;
+};
+export type CollectionStates = Partial<Record<CollectionSurface, CollectionState>>;
+export type CollectionArray<T> = T[] & {
+    collectionState?: CollectionState;
+};
+/** One cached provider page per requested surface. Zero marks an exhausted source. */
+export declare function fetchCollectionPage<T>(identity: {
+    owner: string;
+    repo: string;
+    prNumber: number;
+    surface: CollectionSurface;
+}, page: number, fetchPage: (page: number) => Promise<{
+    data: T[];
+    headers?: {
+        link?: string;
+    };
+}>, authInfo?: AuthInfo): Promise<{
+    items: T[];
+    rawResponseChars: number;
+    collectionState: CollectionState;
+}>;

package/dist/github/prContentFetcher/comments.d.ts

@@ -1,11 +1,13 @@
 import { PRCommentItem, PRReviewInfo } from '../githubAPI.js';
 import { OctokitWithThrottling } from '../client.js';
-export declare function fetchPRComments(octokit: InstanceType<typeof OctokitWithThrottling>, owner: string, repo: string, prNumber: number, includeBots?: boolean): Promise<{
-    comments: PRCommentItem[];
+import type { AuthInfo } from '@modelcontextprotocol/server';
+import { type CollectionArray } from './collectionPaging.js';
+export declare function fetchPRComments(octokit: InstanceType<typeof OctokitWithThrottling>, owner: string, repo: string, prNumber: number, includeBots?: boolean, authInfo?: AuthInfo, collectionPage?: number): Promise<{
+    comments: CollectionArray<PRCommentItem>;
     note?: string;
 }>;
-export declare function fetchPRReviews(octokit: InstanceType<typeof OctokitWithThrottling>, owner: string, repo: string, prNumber: number): Promise<PRReviewInfo[]>;
-export declare function fetchPRInlineComments(octokit: InstanceType<typeof OctokitWithThrottling>, owner: string, repo: string, prNumber: number, includeBots?: boolean): Promise<{
-    comments: PRCommentItem[];
+export declare function fetchPRReviews(octokit: InstanceType<typeof OctokitWithThrottling>, owner: string, repo: string, prNumber: number, authInfo?: AuthInfo, collectionPage?: number): Promise<CollectionArray<PRReviewInfo>>;
+export declare function fetchPRInlineComments(octokit: InstanceType<typeof OctokitWithThrottling>, owner: string, repo: string, prNumber: number, includeBots?: boolean, authInfo?: AuthInfo, collectionPage?: number): Promise<{
+    comments: CollectionArray<PRCommentItem>;
     note?: string;
 }>;

package/dist/github/prContentFetcher/commits.d.ts

@@ -1,27 +1,26 @@
-import { GitHubPullRequestsSearchParams, CommitInfo, DiffEntry, CommitFileInfo } from '../githubAPI.js';
+import { GitHubPullRequestsSearchParams, CommitInfo, DiffEntry, CommitFileInfo, PRProviderLimit } from '../githubAPI.js';
 import { AuthInfo } from '@modelcontextprotocol/server';
-export declare function fetchAllPaginated<T>(fetchPage: (page: number) => Promise<{
-    data: T[];
-}>): Promise<{
-    items: T[];
-    rawResponseChars: number;
-}>;
-export declare function fetchPRFileChangesAPI(owner: string, repo: string, prNumber: number, authInfo?: AuthInfo): Promise<{
+import { type CollectionState } from './collectionPaging.js';
+type WithProviderLimits<T> = T & {
+    providerLimits?: PRProviderLimit[];
+    collectionState?: CollectionState;
+};
+export declare function fetchPRFileChangesAPI(owner: string, repo: string, prNumber: number, authInfo?: AuthInfo, collectionPage?: number): Promise<WithProviderLimits<{
     total_count: number;
     files: DiffEntry[];
-} | null>;
+}> | null>;
 interface CommitListItem {
     sha: string;
     commit: {
         message: string;
         author: {
-            name: string;
-            date: string;
+            name?: string;
+            date?: string;
         } | null;
     };
 }
-export declare function fetchPRCommitsAPI(owner: string, repo: string, prNumber: number, authInfo?: AuthInfo): Promise<CommitListItem[] | null>;
-export declare function fetchCommitFilesAPI(owner: string, repo: string, sha: string, authInfo?: AuthInfo): Promise<CommitFileInfo[] | null>;
+export declare function fetchPRCommitsAPI(owner: string, repo: string, prNumber: number, authInfo?: AuthInfo, collectionPage?: number): Promise<WithProviderLimits<CommitListItem[]> | null>;
+export declare function fetchCommitFilesAPI(owner: string, repo: string, sha: string, authInfo?: AuthInfo): Promise<WithProviderLimits<CommitFileInfo[]> | null>;
 export declare function mapPool<T, R>(items: T[], concurrency: number, mapper: (item: T, index: number) => Promise<R>): Promise<R[]>;
-export declare function fetchPRCommitsWithFiles(owner: string, repo: string, prNumber: number, params: GitHubPullRequestsSearchParams, authInfo?: AuthInfo): Promise<CommitInfo[] | null>;
+export declare function fetchPRCommitsWithFiles(owner: string, repo: string, prNumber: number, params: GitHubPullRequestsSearchParams, authInfo?: AuthInfo): Promise<WithProviderLimits<CommitInfo[]> | null>;
 export {};

package/dist/github/prContentFetcher/flags.d.ts

@@ -18,4 +18,3 @@ export declare function shouldFetchReviews(params: GitHubPullRequestsSearchParam
  */
 export declare function shouldEnrichPullRequestFromSearch(params: GitHubPullRequestsSearchParams): boolean;
 export declare function shouldIncludeBotComments(params: GitHubPullRequestsSearchParams): boolean;
-export declare function stripMachineBlobs(body: string): string;

package/dist/github/prContentFetcher/transform.d.ts

@@ -1,5 +1,5 @@
 import { GitHubPullRequestsSearchParams, GitHubPullRequestItem, IssueSearchResultItem, PullRequestSimple, PullRequestItem } from '../githubAPI.js';
 import { OctokitWithThrottling } from '../client.js';
 import { AuthInfo } from '@modelcontextprotocol/server';
-export declare function transformPullRequestItemFromSearch(item: IssueSearchResultItem, params: GitHubPullRequestsSearchParams, octokit: InstanceType<typeof OctokitWithThrottling>): Promise<GitHubPullRequestItem>;
+export declare function transformPullRequestItemFromSearch(item: IssueSearchResultItem, params: GitHubPullRequestsSearchParams, octokit: InstanceType<typeof OctokitWithThrottling>, authInfo?: AuthInfo): Promise<GitHubPullRequestItem>;
 export declare function transformPullRequestItemFromREST(item: PullRequestSimple | PullRequestItem, params: GitHubPullRequestsSearchParams, octokit: InstanceType<typeof OctokitWithThrottling>, authInfo?: AuthInfo): Promise<GitHubPullRequestItem>;

package/dist/github/prTransformation.d.ts

@@ -89,7 +89,6 @@ export declare function formatPRForResponse(pr: GitHubPullRequestItem, options?:
         name: string;
         color: string;
     }[];
-    number: number;
     title: string;
     state: "open" | "closed";
     draft: boolean;
@@ -99,6 +98,9 @@ export declare function formatPRForResponse(pr: GitHubPullRequestItem, options?:
     closedAt: string;
     mergedAt: string;
     author: string;
+    providerLimits?: import("./githubAPI.js").PRProviderLimit[];
+    collectionStates?: Partial<Record<import("./prContentFetcher/collectionPaging.js").CollectionSurface, import("./prContentFetcher/collectionPaging.js").CollectionState>>;
+    number: number;
 };
 export declare function normalizeOwnerRepo(params: GitHubPullRequestsSearchParams): {
     owner: string | undefined;

package/dist/github/queryBuilders/codeAndRepo.d.ts

@@ -1,5 +1,6 @@
 import type { z } from 'zod';
-import type { GitHubCodeSearchQuerySchema, GitHubReposSearchSingleQuerySchema } from '../../toolContract/schemas.js';
+import type { GitHubCodeSearchQuerySchema } from '../../toolContract/input/resources/tools/githubCodeOperation.js';
+import type { GitHubReposSearchSingleQuerySchema } from '../../toolContract/input/resources/tools/githubRepositoriesOperation.js';
 type GitHubCodeSearchQuery = z.infer<typeof GitHubCodeSearchQuerySchema>;
 type GitHubReposSearchSingleQuery = z.infer<typeof GitHubReposSearchSingleQuerySchema>;
 import type { WithOptionalMeta } from '../../types/execution.js';

package/dist/github/repoSearch.d.ts

@@ -1,6 +1,6 @@
 import type { GitHubAPIResponse } from './githubAPI.js';
 import type { z } from 'zod';
-import type { GitHubReposSearchSingleQuerySchema } from '../toolContract/schemas.js';
+import type { GitHubReposSearchSingleQuerySchema } from '../toolContract/input/resources/tools/githubRepositoriesOperation.js';
 import type { GitHubRepositoryOutput } from '@octocodeai/octocode-core/extra-types';
 type GitHubReposSearchSingleQuery = z.infer<typeof GitHubReposSearchSingleQuerySchema>;
 import type { WithOptionalMeta } from '../types/execution.js';
@@ -18,6 +18,7 @@ interface RepoSearchPagination {
 }
 interface RepoSearchAPIData {
     repositories: GitHubRepositoryOutput[];
+    incompleteResults?: boolean;
     pagination?: RepoSearchPagination;
     nonExistentScope?: boolean;
 }

package/dist/github/repoStructure/fetchOrchestration.d.ts

@@ -1,6 +1,6 @@
 import type { z } from 'zod';
 import { AuthInfo } from '@modelcontextprotocol/server';
-import type { GitHubViewRepoStructureQuerySchema } from '../../toolContract/schemas.js';
+import type { GitHubViewRepoStructureQuerySchema } from '../../toolContract/input/resources/tools/githubTreeOperation.js';
 type GitHubViewRepoStructureQuery = z.infer<typeof GitHubViewRepoStructureQuerySchema>;
 import type { GitHubRepositoryStructureResult, GitHubRepositoryStructureError } from '../../tools/github_view_repo_structure/types.js';
 export declare function viewGitHubRepositoryStructureAPI(params: GitHubViewRepoStructureQuery, authInfo?: AuthInfo, sessionId?: string): Promise<GitHubRepositoryStructureResult | GitHubRepositoryStructureError>;

package/dist/github/repoStructurePagination.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { GitHubViewRepoStructureQuerySchema } from '../toolContract/schemas.js';
+import type { GitHubViewRepoStructureQuerySchema } from '../toolContract/input/resources/tools/githubTreeOperation.js';
 type GitHubViewRepoStructureQuery = z.infer<typeof GitHubViewRepoStructureQuerySchema>;
 import type { GitHubRepositoryStructureResult } from '../tools/github_view_repo_structure/types.js';
 export declare function applyStructurePagination(cachedResult: GitHubRepositoryStructureResult, params: GitHubViewRepoStructureQuery): GitHubRepositoryStructureResult;

package/dist/github/repoStructureTree.d.ts

@@ -25,8 +25,10 @@ export declare function filterGitTreeEntries(tree: GitTreeEntry[], options: {
 }): GitHubApiFileItem[];
 export declare function isGitStructureTreesEnabled(env?: NodeJS.ProcessEnv): boolean;
 /**
- * Fetch a repo tree via `git.getTree({ recursive: 'true' })` and filter to the
- * requested path/depth. Resolves branch → tree SHA in two REST calls total.
+ * Resolve the requested directory's immutable tree SHA, then fetch its tree.
+ * Root queries use branch metadata; scoped queries find the directory in its
+ * parent's Contents listing. Both paths use two REST calls, without downloading
+ * unrelated recursive subtrees for a scoped query.
  */
 export declare function fetchStructureViaGitTree(octokit: Octokit, params: {
     owner: string;

package/dist/graph/advancedOperations.d.ts

@@ -1,6 +1,6 @@
 import type { FileGraphEdgeKind, FileNode } from './types.js';
-/** Remove edges that exist only for erased type imports. */
-export declare function withoutTypeOnlyEdges(graph: ReadonlyMap<string, FileNode>): Map<string, FileNode>;
+/** Runtime import candidates; Rust names/modules and C preprocessing are topology only. */
+export declare function runtimeImportGraph(graph: ReadonlyMap<string, FileNode>): Map<string, FileNode>;
 export interface CondensedGraph {
     components: string[][];
     componentOf: Map<string, number>;

package/dist/graph/buildFileGraph.d.ts

@@ -1,8 +1,9 @@
-import type { FileFacts, FileNode } from './types.js';
+import type { FileFacts, FileNode, GraphCoverage } from './types.js';
 export declare const DEFAULT_DEAD_CODE_EXCLUDE_DIRS: string[];
 /** Keep generated/vendor defaults while allowing callers to add repo-specific exclusions. */
 export declare function resolveGraphExcludeDirs(custom: readonly string[] | undefined): string[];
 export interface WalkResult {
+    coverage?: GraphCoverage;
     facts: Map<string, FileFacts>;
     fileGraph: Map<string, FileNode>;
     filesScanned: number;
@@ -16,23 +17,17 @@ export interface WalkResult {
      */
     starReexportTargets: Set<string>;
     /**
-     * Files that are the target of a string-literal dynamic `import('./x')`
-     * somewhere in the scan. A dynamic import resolves the whole module
-     * namespace, not a specific named binding, so — unlike a static
-     * `import { x } from './y'` — there is no reliable way to attribute which
-     * of the target's exports are actually used. Treated the same as
-     * `starReexportTargets`: reachable, and not individually retention-checked,
-     * rather than risk a false-positive "unreferenced export" on a name that's
-     * genuinely read off the dynamically-imported namespace object.
+     * Targets consumed as whole namespaces (dynamic/CommonJS loads, namespace
+     * imports, and C headers). Retain their public surface because syntax facts
+     * cannot attribute the particular exported bindings consumed downstream.
      */
-    dynamicImportTargets: Set<string>;
+    namespaceImportTargets: Set<string>;
     /**
      * Reverse star-re-export edges: target file → the files that
      * `export * from` it. Needed for retention: a NAMED re-export whose barrel
      * is itself star-re-exported (barrel → `export *` → entrypoint) is public
      * API — `isBindingLive` must be able to hop the star edge, which carries no
-     * per-name entry in the named `reexportIndex`. Unfiltered (all scanned
-     * files); the scan filters to reachable re-exporters before use.
+     * per-name `reexportIndex` entry. Filtered to reachable re-exporters at use.
      */
     starReexporters: Map<string, string[]>;
 }
@@ -41,4 +36,4 @@ export interface WalkResult {
  * worker-pool operation, then resolve import specifiers into a file-level graph.
  * Cross-file policy stays here; filesystem I/O and parsing stay in Rust.
  */
-export declare function buildFileGraph(rootAbsolutePath: string, excludeDir: string[], maxFiles: number): Promise<WalkResult>;
+export declare function buildFileGraph(rootAbsolutePath: string, excludeDir: string[], maxFiles: number, rustWorkspace?: 'syntax' | 'cargo'): Promise<WalkResult>;

package/dist/graph/coverage.d.ts

@@ -0,0 +1,6 @@
+import type { GraphCoverage, RawGraphFacts } from './types.js';
+type Diagnostic = GraphCoverage['diagnostics'][number];
+export declare function recordUnlinkedCommonJsCalls(coverage: GraphCoverage, file: string, calls: RawGraphFacts['calls']): void;
+/** One diagnostic per source occurrence, independent of binding or scan order. */
+export declare function canonicalGraphDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[];
+export {};

package/dist/graph/diagnosticSnapshot.d.ts

@@ -0,0 +1,10 @@
+import type { GraphCoverage } from './types.js';
+type Diagnostic = GraphCoverage['diagnostics'][number];
+interface PreparedDiagnostics {
+    diagnostics: Diagnostic[];
+    resultId: string;
+    diagnosticCounts: Readonly<Record<string, number>>;
+}
+/** An immutable diagnostic inventory belonging to one completed graph scan. */
+export declare function prepareGraphDiagnostics(items: readonly Diagnostic[]): PreparedDiagnostics;
+export {};