@octocodeai/octocode-tools-core 17.0.2 → 18.1.0

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

@@ -12,6 +12,16 @@ export interface DirectToolDefinition {
     name: string;
     schema: z.ZodType;
     inputSchema: z.ZodType;
+    /**
+     * Present only for opt-in tools (ghListReleases/ghSearchDiscussions) that
+     * are NOT currently enabled. Their entry still appears here (schema/help
+     * stay discoverable via `tools <name> --scheme` without already knowing the
+     * env var) — the runtime execution registry (`ALL_TOOLS` in toolConfig.ts)
+     * is the actual enforcement point and still omits them until enabled.
+     */
+    disabled?: {
+        envVar: string;
+    };
 }
 export type DirectToolCategory = 'GitHub' | 'Local Code' | 'Package' | 'Other';
 export declare const DIRECT_TOOL_CATEGORIES: readonly DirectToolCategory[];
@@ -29,11 +39,6 @@ export interface DirectToolCommandPattern {
     query: Record<string, unknown>;
     command: string;
 }
-export interface DirectToolOutputField {
-    name: string;
-    type: string;
-    optional?: boolean;
-}
 export interface DirectToolMetadata {
     tools?: Record<string, {
         description?: string;
@@ -60,9 +65,3 @@ 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;

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

@@ -0,0 +1,5 @@
+import { type DirectToolMetadata } from './toolCatalogDefinitions.js';
+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 getDirectToolDescription(toolName: string, metadata?: DirectToolMetadata | null): string;

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

@@ -21,6 +21,7 @@
  * should need to import those sibling modules directly; import from here.
  */
 export * from './directToolCatalog/toolCatalogDefinitions.js';
+export * from './directToolCatalog/toolCatalogFormatters.js';
 export * from './directToolCatalog/toolSchemaIntrospection.js';
 export * from './directToolCatalog/toolCommandPatterns.js';
 export * from './directToolCatalog/toolInputPreparation.js';

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

@@ -0,0 +1,9 @@
+/**
+ * Size of a clone's checked-out working tree, excluding the top-level `.git`
+ * directory. The shared `getDirectorySizeBytes` counts everything, so a sparse
+ * blob:none checkout of a few KB still reports the ~1MB packed-git floor —
+ * making `totalSize`/`rawResponse` reflect Git plumbing, not the content the
+ * caller actually received. `.git` only lives at the clone root, so skipping it
+ * there and reusing the shared walker for every other subtree is sufficient.
+ */
+export declare function getCheckedOutSizeBytes(targetPath: string): number;

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

@@ -1,3 +1,5 @@
+import type { ToolContinuation } from '../../scheme/pagination.js';
+import type { ResponsePaginationInfo } from '../../types/toolOutput.js';
 export declare const CloneRepoQueryLocalSchema: import("zod").ZodObject<{
     owner: import("zod").ZodString;
     repo: import("zod").ZodString;
@@ -14,83 +16,29 @@ export declare const BulkCloneRepoLocalSchema: import("zod").ZodObject<{
     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<{
-    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;
-        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>;
-    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>;
-    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;
-        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>;
+interface GitHubCloneRepoData {
+    localPath: string;
+    resolvedBranch?: string;
+    cached?: boolean;
+    sparsePath?: string;
+    cloneTimeMs?: number;
+    totalSize?: number;
+    fileCount?: number;
+    location?: Record<string, unknown>;
+}
+export type GitHubCloneRepoOutputLocal = {
+    status?: string;
+    data?: GitHubCloneRepoData;
+    localPath?: string;
+    resolvedBranch?: string;
+    cached?: boolean;
+    sparsePath?: string;
+    location?: Record<string, unknown>;
+    warnings?: string[];
+    error?: string;
+    base?: string;
+    shared?: Record<string, string | number | boolean>;
+    responsePagination?: ResponsePaginationInfo;
+    next?: Record<string, ToolContinuation>;
+} & Record<string, unknown>;
+export {};

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

@@ -9,13 +9,13 @@ export type PartialFileContentQuery = WithOptionalMeta<FileContentQuery> & Query
 export type FileEntry = {
     path: string;
     content: string;
+    /** Coarse file bucket to guide how bytes are read; omitted when uncertain. */
+    fileType?: 'code' | 'config' | 'lock' | 'doc';
     localPath?: string;
     repoRoot?: string;
-    fileSize?: number;
     contentView?: 'none' | 'standard' | 'symbols';
     totalLines?: number;
     sourceChars?: number;
-    sourceBytes?: number;
     resolvedBranch?: string;
     pagination?: PaginationInfo;
     isPartial?: boolean;
@@ -25,6 +25,8 @@ export type FileEntry = {
         start: number;
         end: number;
     }>;
+    /** Exact matched-line numbers (matchRanges are ±contextLines windows around them). */
+    matchedLines?: number[];
     lastModified?: string;
     lastModifiedBy?: string;
     warnings?: string[];
@@ -89,7 +91,6 @@ export type RepoGroup = {
     repo: string;
     files?: FileEntry[];
     directories?: DirectoryEntry[];
-    data?: RepoGroupData;
 };
 export type RepoGroupData = {
     owner: string;

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

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import type { CharPagination, ItemPagination, ToolContinuation } from '../../scheme/pagination.js';
+import type { ResponsePaginationInfo } from '../../types/toolOutput.js';
 export declare const FileContentQueryBaseLocalSchema: z.ZodObject<Readonly<{
     [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
 }>, z.core.$strip>;
@@ -36,143 +38,93 @@ export declare const FileContentBulkQueryLocalSchema: z.ZodObject<{
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strip>;
-export declare const 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;
-        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";
-                }>>;
-                totalLines: z.ZodOptional<z.ZodNumber>;
-                sourceChars: z.ZodOptional<z.ZodNumber>;
-                sourceBytes: z.ZodOptional<z.ZodNumber>;
-                resolvedBranch: z.ZodOptional<z.ZodString>;
-                modified: z.ZodOptional<z.ZodString>;
-                fileSize: z.ZodOptional<z.ZodNumber>;
-                pagination: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-                    charOffset: z.ZodNumber;
-                    charLength: z.ZodNumber;
-                    totalChars: z.ZodNumber;
-                    hasMore: z.ZodBoolean;
-                    nextCharOffset: z.ZodOptional<z.ZodNumber>;
-                    currentPage: z.ZodOptional<z.ZodNumber>;
-                    totalPages: z.ZodOptional<z.ZodNumber>;
-                    chunkMode: z.ZodOptional<z.ZodEnum<{
-                        semantic: "semantic";
-                        "char-limit": "char-limit";
-                    }>>;
-                    nextPage: z.ZodOptional<z.ZodNumber>;
-                }, z.core.$strip>, z.ZodObject<{
-                    currentPage: z.ZodNumber;
-                    totalPages: z.ZodNumber;
-                    hasMore: z.ZodBoolean;
-                    nextPage: z.ZodOptional<z.ZodNumber>;
-                    pageSize: z.ZodOptional<z.ZodNumber>;
-                    totalItems: z.ZodOptional<z.ZodNumber>;
-                    perPage: z.ZodOptional<z.ZodNumber>;
-                    totalFound: z.ZodOptional<z.ZodNumber>;
-                    returned: z.ZodOptional<z.ZodNumber>;
-                    totalMatches: z.ZodOptional<z.ZodNumber>;
-                    reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
-                    reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
-                    totalMatchesKind: z.ZodOptional<z.ZodEnum<{
-                        exact: "exact";
-                        reported: "reported";
-                        lowerBound: "lowerBound";
-                    }>>;
-                    totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
-                    totalResults: z.ZodOptional<z.ZodNumber>;
-                    itemsPerPage: z.ZodOptional<z.ZodNumber>;
-                    charOffset: z.ZodOptional<z.ZodNumber>;
-                    charLength: z.ZodOptional<z.ZodNumber>;
-                    totalChars: z.ZodOptional<z.ZodNumber>;
-                    nextCharOffset: z.ZodOptional<z.ZodNumber>;
-                }, z.core.$strip>]>>;
-                next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                    tool: z.ZodString;
-                    query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                    why: z.ZodOptional<z.ZodString>;
-                    confidence: z.ZodOptional<z.ZodEnum<{
-                        exact: "exact";
-                        heuristic: "heuristic";
-                    }>>;
-                }, z.core.$strip>>>;
-                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>>;
-    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;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type GitHubFetchContentOutputLocal = z.infer<typeof GitHubFetchContentOutputLocalSchema>;
+export type GitHubFetchFilePagination = (CharPagination & {
+    nextPage?: number;
+}) | (ItemPagination & {
+    charOffset?: number;
+    charLength?: number;
+    totalChars?: number;
+    nextCharOffset?: number;
+});
+export interface GitHubFetchFileEntry {
+    path: string;
+    content: string;
+    localPath?: string;
+    repoRoot?: string;
+    contentView?: 'none' | 'standard' | 'symbols';
+    totalLines?: number;
+    sourceChars?: number;
+    resolvedBranch?: string;
+    pagination?: GitHubFetchFilePagination;
+    next?: Record<string, ToolContinuation>;
+    isPartial?: boolean;
+    startLine?: number;
+    endLine?: number;
+    matchRanges?: Array<{
+        start: number;
+        end: number;
+    }>;
+    lastModified?: string;
+    lastModifiedBy?: string;
+    warnings?: string[];
+    matchNotFound?: boolean;
+    searchedFor?: string;
+    cached?: boolean;
+}
+export interface GitHubFetchDirectoryEntry {
+    path: string;
+    localPath: string;
+    repoRoot?: string;
+    fileCount: number;
+    totalSize: number;
+    complete?: 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[];
+    files?: Array<{
+        path: string;
+        size: number;
+        type: string;
+    }>;
+    cached?: boolean;
+    resolvedBranch?: string;
+}
+export interface GitHubFetchContentData {
+    owner: string;
+    repo: string;
+    files?: GitHubFetchFileEntry[];
+    directories?: GitHubFetchDirectoryEntry[];
+}
+export interface GitHubFetchContentOutputLocal {
+    base?: string;
+    shared?: Record<string, string | number | boolean>;
+    responsePagination?: ResponsePaginationInfo;
+    results: Array<{
+        id: string;
+        data?: GitHubFetchContentData;
+    }>;
+    errors?: Array<{
+        id: string;
+        owner?: string;
+        repo?: string;
+        path?: string;
+        error: string;
+    }>;
+    [key: string]: unknown;
+}

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

@@ -25,11 +25,12 @@ export interface GitHubFileContentApiData {
     isPartial?: boolean;
     totalLines?: number;
     sourceChars?: number;
-    sourceBytes?: number;
     matchRanges?: Array<{
         start: number;
         end: number;
     }>;
+    /** Exact matched-line numbers (matchRanges are ±contextLines windows around them). */
+    matchedLines?: number[];
     matchLocations?: string[];
     warnings?: string[];
     lastModified?: string;

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

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import type { ItemPagination } from '../../scheme/pagination.js';
+import type { BulkToolOutput } from '../../types/toolOutput.js';
 export declare const GitHubCodeSearchQueryLocalSchema: z.ZodObject<{
     keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
     owner: z.ZodOptional<z.ZodString>;
@@ -24,90 +26,40 @@ export declare const GitHubCodeSearchBulkQueryLocalSchema: z.ZodObject<{
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strip>;
-export declare const 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.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                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;
-                        lineOffset: 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;
-                hasMore: z.ZodBoolean;
-                nextPage: z.ZodOptional<z.ZodNumber>;
-                pageSize: z.ZodOptional<z.ZodNumber>;
-                totalItems: z.ZodOptional<z.ZodNumber>;
-                perPage: z.ZodOptional<z.ZodNumber>;
-                totalFound: z.ZodOptional<z.ZodNumber>;
-                returned: z.ZodOptional<z.ZodNumber>;
-                totalMatches: z.ZodOptional<z.ZodNumber>;
-                reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
-                reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
-                totalResults: z.ZodOptional<z.ZodNumber>;
-                itemsPerPage: z.ZodOptional<z.ZodNumber>;
-                totalMatchesKind: z.ZodOptional<z.ZodEnum<{
-                    exact: "exact";
-                    reported: "reported";
-                    lowerBound: "lowerBound";
-                }>>;
-                totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
-                uniqueFileCount: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
-    }, z.core.$strip>>;
-    emptyQueries: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        nonExistentScope: z.ZodOptional<z.ZodLiteral<true>>;
-        incompleteResults: z.ZodOptional<z.ZodLiteral<true>>;
-    }, z.core.$strip>>>;
-    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        level: z.ZodEnum<{
-            error: "error";
-            info: "info";
-            warning: "warning";
-        }>;
-        message: z.ZodString;
-        field: z.ZodOptional<z.ZodString>;
-        code: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        tool: z.ZodString;
-        query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        why: z.ZodOptional<z.ZodString>;
-        confidence: z.ZodOptional<z.ZodEnum<{
-            exact: "exact";
-            heuristic: "heuristic";
-        }>>;
-    }, z.core.$strip>>>;
-    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        error: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type GitHubCodeSearchOutputLocal = z.infer<typeof GitHubCodeSearchOutputLocalSchema>;
+export interface CodeSearchPaginationLocal extends ItemPagination {
+    totalMatchesKind?: 'exact' | 'reported' | 'lowerBound';
+    totalMatchesCapped?: boolean;
+    uniqueFileCount?: number;
+}
+export interface GitHubCodeSearchFileMatch {
+    value?: string;
+    pathOnly?: boolean;
+    matchIndices?: Array<{
+        start: number;
+        end: number;
+        lineOffset: number;
+    }>;
+}
+export interface GitHubCodeSearchFile {
+    owner: string;
+    repo: string;
+    path: string;
+    queryId?: string;
+    matches: GitHubCodeSearchFileMatch[];
+}
+export interface GitHubCodeSearchData {
+    files: Array<string | GitHubCodeSearchFile>;
+    pagination?: CodeSearchPaginationLocal;
+}
+export type GitHubCodeSearchOutputLocal = BulkToolOutput<GitHubCodeSearchData> & {
+    emptyQueries?: Array<{
+        id: string;
+        nonExistentScope?: true;
+        incompleteResults?: true;
+    }>;
+    errors?: Array<{
+        id: string;
+        error: string;
+    }>;
+    [key: string]: unknown;
+};

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

@@ -0,0 +1,15 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+type PartialDiscussionsQuery = {
+    owner?: string;
+    repo?: string;
+    keywordsToSearch?: string[];
+    itemsPerPage?: number;
+    limit?: number;
+    after?: string;
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+};
+export declare function searchMultipleGitHubDiscussions(args: ToolExecutionArgs<PartialDiscussionsQuery>): Promise<CallToolResult>;
+export {};

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

@@ -0,0 +1,16 @@
+export declare const SearchDiscussionsLocalSchema: import("zod").ZodObject<{
+    owner: import("zod").ZodString;
+    repo: import("zod").ZodString;
+    keywordsToSearch: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    itemsPerPage: import("zod").ZodDefault<import("zod").ZodNumber>;
+    after: import("zod").ZodOptional<import("zod").ZodString>;
+    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 SearchDiscussionsBulkLocalSchema: import("zod").ZodObject<{
+    responseCharOffset: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNumber>>;
+    responseCharLength: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNumber>>;
+    queries: import("zod").ZodArray<import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>>;
+}, import("zod/v4/core").$strip>;