@octocodeai/octocode-tools-core 18.1.2 → 18.2.0

package/dist/toolContract/input/resources/tools/lspGetSemantics.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import type { ToolSpec } from '../../types/index.js';
+export declare const lspGetSemantics: ToolSpec;
+export declare const LspGetSemanticsQuerySchema: z.ZodObject<{
+    uri: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<{
+        definition: "definition";
+        documentSymbols: "documentSymbols";
+        workspaceSymbol: "workspaceSymbol";
+        references: "references";
+        callers: "callers";
+        callees: "callees";
+        callHierarchy: "callHierarchy";
+        hover: "hover";
+        typeDefinition: "typeDefinition";
+        implementation: "implementation";
+        supertypes: "supertypes";
+        subtypes: "subtypes";
+        diagnostic: "diagnostic";
+    }>>;
+    symbolName: z.ZodOptional<z.ZodString>;
+    lineHint: z.ZodOptional<z.ZodNumber>;
+    orderHint: z.ZodDefault<z.ZodNumber>;
+    depth: z.ZodOptional<z.ZodNumber>;
+    includeDeclaration: z.ZodDefault<z.ZodBoolean>;
+    groupByFile: z.ZodOptional<z.ZodBoolean>;
+    page: z.ZodDefault<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    contextLines: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodDefault<z.ZodEnum<{
+        structured: "structured";
+        compact: "compact";
+    }>>;
+    workspaceRoot: z.ZodOptional<z.ZodString>;
+    goal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/toolContract/input/resources/tools/npmSearch.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import type { ToolSpec } from '../../types/index.js';
+export declare const npmSearch: ToolSpec;
+export declare const NpmPackageQuerySchema: z.ZodObject<{
+    packageName: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    page: z.ZodDefault<z.ZodNumber>;
+    goal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/toolContract/input/types/index.d.ts

@@ -0,0 +1,24 @@
+export interface ToolNames {
+    GITHUB_SEARCH: 'ghSearch';
+    GITHUB_FETCH_CONTENT: 'ghGetFileContent';
+    GITHUB_SEARCH_HISTORY: 'ghSearchHistory';
+    GITHUB_GET_HISTORY_ITEM: 'ghGetHistoryItem';
+    PACKAGE_SEARCH: 'npmSearch';
+    GITHUB_CLONE_REPO: 'ghCloneRepo';
+    LOCAL_SEARCH: 'localSearch';
+    LOCAL_ANALYZE_GRAPH: 'localAnalyzeGraph';
+    LOCAL_FETCH_CONTENT: 'localGetFileContent';
+    LSP_GET_SEMANTIC_CONTENT: 'lspGetSemantics';
+}
+export interface ToolSchema {
+    readonly [param: string]: string;
+}
+export type ToolType = 'Github' | 'Local' | 'NPM';
+export interface ToolSpec {
+    readonly name: string;
+    readonly type: ToolType;
+    readonly shortDescription: string;
+    readonly instructions: string;
+    readonly description: string;
+    readonly schema: ToolSchema;
+}

package/dist/toolContract/metadata.d.ts

@@ -0,0 +1,11 @@
+/** Shared prompt plus the canonical tools-core-owned executable catalog. */
+export declare const localCompleteMetadata: {
+    systemPrompt: string;
+    toolNames: import("./types.js").ToolNames;
+    baseSchema: Record<"goal" | "reasoning", string>;
+    tools: {
+        [k: string]: {
+            description: string;
+        };
+    };
+};

package/dist/toolContract/runtime.d.ts

@@ -0,0 +1,11 @@
+import type { z } from 'zod';
+import { RipgrepQuerySchema } from './schemas.js';
+type RuntimeRipgrepQuery = z.infer<typeof RipgrepQuerySchema>;
+export interface RipgrepValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export declare function validateRipgrepQuery(query: RuntimeRipgrepQuery): RipgrepValidationResult;
+export declare function applyWorkflowMode<T extends RuntimeRipgrepQuery>(query: T): T;
+export {};

package/dist/toolContract/schemas.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Internal input-schema primitives owned by tools-core.
+ *
+ * Public canonical schemas are exported from each direct tool's scheme and
+ * assembled by the direct-tool catalog. This barrel intentionally has no
+ * second tool-name registry.
+ */
+export { baseSchema, baseSchemaDescriptions, toolNames, } from './input/resources/global.js';
+export type { BaseSchemaShape } from './input/resources/global.js';
+export { getToolSchemaRelations } from './input/resources/toolRelations.js';
+export { getToolSchemaVariants } from './input/resources/toolVariants.js';
+export type { ToolSchemaVariant } from './input/resources/toolVariants.js';
+export { MAX_CONTEXT_LINES, MAX_PAGE_NUMBER, MAX_CHAR_OFFSET, MAX_CHAR_LENGTH, MAX_LINE_NUMBER, MAX_ORDER_HINT, MAX_LOCAL_DEPTH, MAX_FIND_DEPTH, MAX_LOCAL_LIMIT, MAX_LOCAL_ITEMS_PER_PAGE, MAX_GITHUB_SEARCH_LIMIT, DEFAULT_GITHUB_SEARCH_LIMIT, MAX_GITHUB_STRUCTURE_ITEMS_PER_PAGE, DEFAULT_GITHUB_STRUCTURE_ITEMS_PER_PAGE, MAX_PR_ITEMS_PER_PAGE, DEFAULT_PR_ITEMS_PER_PAGE, MAX_MATCH_CONTENT_LENGTH, DEFAULT_MATCH_CONTENT_LENGTH, MAX_MATCH_COUNT, MAX_SEARCH_ITEMS_PER_PAGE, MAX_LSP_DEPTH, MAX_LSP_ITEMS_PER_PAGE, MAX_GITHUB_STRUCTURE_DEPTH, } from './input/resources/tools/_toolkit.js';
+export { GitHubSearchQuerySchema } from './input/resources/tools/ghSearch.js';
+export { GitHubCodeSearchQuerySchema } from './input/resources/tools/githubCodeOperation.js';
+export { FileContentQuerySchema } from './input/resources/tools/ghGetFileContent.js';
+export { GitHubViewRepoStructureQuerySchema } from './input/resources/tools/githubTreeOperation.js';
+export { GitHubReposSearchSingleQuerySchema } from './input/resources/tools/githubRepositoriesOperation.js';
+export { GitHubPullRequestSearchQuerySchema } from './input/resources/tools/githubHistorySchema.js';
+export { SearchPullRequestsQuerySchema } from './input/resources/tools/historyPullRequestInput.js';
+export { SearchIssuesQuerySchema } from './input/resources/tools/historyIssueInput.js';
+export { SearchCommitsQuerySchema } from './input/resources/tools/historyCommitInput.js';
+export { NpmPackageQuerySchema } from './input/resources/tools/npmSearch.js';
+export { CloneRepoQuerySchema } from './input/resources/tools/ghCloneRepo.js';
+export { LocalSearchQuerySchema } from './input/resources/tools/localSearch.js';
+export { RipgrepQuerySchema } from './input/resources/tools/localTextOperation.js';
+export { ViewStructureQuerySchema } from './input/resources/tools/localTreeOperation.js';
+export { FindFilesQuerySchema } from './input/resources/tools/localFilesOperation.js';
+export { LocalAnalyzeGraphQuerySchema } from './input/resources/tools/localAnalyzeGraph.js';
+export { FetchContentQuerySchema } from './input/resources/tools/localGetFileContent.js';
+export { LspGetSemanticsQuerySchema } from './input/resources/tools/lspGetSemantics.js';

package/dist/toolContract/types.d.ts

@@ -0,0 +1,11 @@
+export type { ToolNames, ToolSchema, ToolSpec, ToolType, } from './input/types/index.js';
+import type { ToolNames } from './input/types/index.js';
+export interface LocalCompleteMetadata {
+    readonly systemPrompt: string;
+    readonly toolNames: ToolNames;
+    readonly baseSchema: Readonly<Record<string, string>>;
+    readonly tools: Readonly<Record<string, {
+        description?: string;
+        schema?: Record<string, string>;
+    }>>;
+}

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

@@ -10,18 +10,10 @@ export type DirectToolInput = Record<string, unknown> & {
 };
 export interface DirectToolDefinition {
     name: string;
+    title: string;
+    description: 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[];
@@ -45,7 +37,7 @@ export interface DirectToolMetadata {
         schema?: Record<string, string>;
     }>;
 }
-export type DirectToolAutoFilledField = 'id' | 'mainResearchGoal' | 'researchGoal' | 'reasoning';
+export type DirectToolAutoFilledField = 'goal' | 'reasoning';
 export interface PrepareDirectToolInputOptions {
     sourceLabel?: string;
     rejectUnknownFields?: boolean;
@@ -56,12 +48,10 @@ export declare class DirectToolInputError extends Error {
     constructor(message: string, details?: string[]);
 }
 export declare const DIRECT_TOOL_AUTO_FILLED_FIELDS: ReadonlySet<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.
- */
+/** Engine-free definitions, derived from the shared specification. */
 export declare const DIRECT_TOOL_DEFINITIONS: DirectToolDefinition[];
+/** Every public direct-tool schema. */
+export declare const DIRECT_TOOL_DISCOVERY_DEFINITIONS: DirectToolDefinition[];
 export declare function findDirectToolDefinition(name: string): DirectToolDefinition | undefined;
 export declare function getDirectToolCategory(toolName: string): DirectToolCategory;
 export declare function sortDirectToolNames(toolNames: string[]): string[];

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

@@ -2,4 +2,4 @@ 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;
+export declare function getDirectToolDescription(toolName: string, _metadata?: DirectToolMetadata | null): string;

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

@@ -0,0 +1,6 @@
+type CommandPattern = {
+    label: string;
+    query: Record<string, unknown>;
+};
+export declare function buildUnifiedSearchCommandPatternQueries(toolName: string): CommandPattern[];
+export {};

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

@@ -1,7 +1,7 @@
 /**
  * Input preparation/normalization for the engine-free direct-tool catalog:
- * JSON parsing, envelope handling, default-field filling, field-name alias
- * folding, and unknown-field detection (with did-you-mean suggestions). Split
+ * JSON parsing, envelope handling, default-field filling, and unknown-field
+ * detection (with did-you-mean suggestions). Split
  * out of `directToolCatalog.meta.ts` (still the public barrel) — see that
  * file's header comment for the full P3 rationale.
  */

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

@@ -6,8 +6,18 @@ interface JsonSchemaObject extends Record<string, unknown> {
     required?: string[];
     properties?: Record<string, unknown>;
     items?: unknown;
+    anyOf?: unknown[];
+    oneOf?: unknown[];
+    const?: unknown;
 }
 export declare function getDirectToolDisplayFields(toolName: string): DirectToolDisplayField[];
+/** Exact per-operation fields for discriminated schemas. Unlike the merged
+ * display view, this preserves branch-specific enums and numeric limits. */
+export declare function getDirectToolVariantDisplayFields(toolName: string): Record<string, DirectToolDisplayField[]>;
+/** Top-level fields accepted by the schema branches compatible with the
+ * selectors already present in a query. This keeps recovery suggestions inside
+ * the active discriminated-union branch instead of the merged catalog view. */
+export declare function getDirectToolAllowedFieldNames(toolName: string, query: Readonly<Record<string, unknown>>): ReadonlySet<string>;
 export declare function describeSchemaConstraints(schema: JsonSchemaObject): string | undefined;
 export declare function describeSchemaType(schema: JsonSchemaObject): string;
 export declare function collectDisplayFields(properties: Record<string, unknown>, requiredFields: ReadonlySet<string>, prefix?: string): DirectToolDisplayField[];

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

@@ -0,0 +1,9 @@
+export declare function getDirectToolSchemaRelations(toolName: string): string[];
+export declare function getDirectToolSchemaVariants(toolName: string): {
+    fields?: string[];
+    requires: string[];
+    name: string;
+    when: string;
+    excludes?: string[];
+    example: Record<string, unknown>;
+}[];

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

@@ -0,0 +1,13 @@
+/**
+ * Engine-free source of truth for public direct-tool names and schemas.
+ * Runtime execution metadata is attached separately by `toolConfig.ts`.
+ */
+import type { z } from 'zod';
+export interface DirectToolSpecification {
+    name: string;
+    title: string;
+    description: string;
+    schema: z.ZodType;
+    inputSchema: z.ZodType;
+}
+export declare const DIRECT_TOOL_SPECIFICATIONS: readonly DirectToolSpecification[];

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

@@ -5,7 +5,7 @@
  * actually runs — schema/help/`--scheme`/`context` use `directToolCatalog.meta.ts`
  * (and the `@octocodeai/octocode-tools-core/schema` subpath), which is engine-free.
  */
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/server';
 import { DirectToolInputError } from './directToolCatalog.meta.js';
 type InitializeFn = () => Promise<void>;
 /** @internal — test use only; not part of the public API. */

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

@@ -25,3 +25,4 @@ export * from './directToolCatalog/toolCatalogFormatters.js';
 export * from './directToolCatalog/toolSchemaIntrospection.js';
 export * from './directToolCatalog/toolCommandPatterns.js';
 export * from './directToolCatalog/toolInputPreparation.js';
+export * from './directToolCatalog/toolSchemaRelations.js';

package/dist/tools/executionGuard.d.ts

@@ -1,7 +1,6 @@
 import type { ProcessedBulkResult } from '../types/toolResults.js';
 interface GuardableQuery {
-    mainResearchGoal?: string;
-    researchGoal?: string;
+    goal?: string;
     reasoning?: string;
 }
 interface ExecutionGuardOptions<TQuery extends GuardableQuery> {

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

@@ -1,4 +1,5 @@
 import type { CloneCacheMeta, CacheSource } from './types.js';
+export { cleanupStaleCloneArtifacts, tryRecoverStaleCloneLock, writeCloneLockMeta, } from './cacheArtifacts.js';
 export { getReposBaseDir, getCloneBaseDir, getTreeBaseDir, getCloneDir, getTreeDir, } from './cachePaths.js';
 export declare function readCacheMeta(cloneDir: string): CloneCacheMeta | null;
 export declare function writeCacheMeta(cloneDir: string, meta: CloneCacheMeta): void;
@@ -17,5 +18,3 @@ 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/cacheArtifacts.d.ts

@@ -0,0 +1,3 @@
+export declare function writeCloneLockMeta(lockDir: string, pid?: number, createdAt?: number): void;
+export declare function tryRecoverStaleCloneLock(lockDir: string, now?: number): boolean;
+export declare function cleanupStaleCloneArtifacts(octocodeDir: string, now?: number): number;

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

@@ -2,4 +2,4 @@ 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 getTreeDir(octocodeDir: string, owner: string, repo: string, commitSha: string): string;

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

@@ -1,4 +1,4 @@
-import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { AuthInfo } from '@modelcontextprotocol/server';
 import type { WithOptionalMeta } from '../../types/execution.js';
 import type { CloneRepoQueryLocalSchema } from './scheme.js';
 import type { z } from 'zod';

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

@@ -1,4 +1,4 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/server';
 import type { ToolExecutionArgs, WithOptionalMeta } from '../../types/execution.js';
 type PartialCloneRepoQuery = WithOptionalMeta<CloneRepoQuery>;
 import type { CloneRepoQueryLocalSchema } from './scheme.js';

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

@@ -1,44 +1,44 @@
 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;
     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>;
+    goal: 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").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>;
-interface GitHubCloneRepoData {
+}, import("zod/v4/core").$strict>;
+interface GitHubCloneRepoLocation {
+    kind: 'repo' | 'tree';
     localPath: string;
-    resolvedBranch?: string;
-    cached?: boolean;
-    sparsePath?: string;
-    cloneTimeMs?: number;
-    totalSize?: number;
-    fileCount?: number;
-    location?: Record<string, unknown>;
+    source: 'clone';
+    cached: boolean;
+    complete: boolean;
+    resolvedBranch: string;
+    requestedPath?: string;
+}
+interface GitHubCloneRepoData {
+    owner: string;
+    repo: string;
+    totalSize: number;
+    location: GitHubCloneRepoLocation;
+    next: {
+        viewStructure: ToolContinuation;
+    };
 }
 export type GitHubCloneRepoOutputLocal = {
-    status?: string;
-    data?: GitHubCloneRepoData;
-    localPath?: string;
-    resolvedBranch?: string;
-    cached?: boolean;
-    sparsePath?: string;
-    location?: Record<string, unknown>;
-    warnings?: string[];
-    error?: string;
+    results: Array<{
+        index: number;
+        status?: 'empty' | 'error';
+        meta?: Record<string, unknown>;
+        data: GitHubCloneRepoData | Record<string, unknown>;
+    }>;
     base?: string;
     shared?: Record<string, string | number | boolean>;
-    responsePagination?: ResponsePaginationInfo;
-    next?: Record<string, ToolContinuation>;
 } & Record<string, unknown>;
 export {};

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

@@ -1,4 +1,4 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/server';
 import type { z } from 'zod';
 import type { ToolExecutionArgs } from '../../types/execution.js';
 import { FileContentQueryLocalSchema } from './scheme.js';

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

@@ -1,9 +1,8 @@
 import type { z } from 'zod';
-import type { FileContentQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { FileContentQuerySchema } from '../../../toolContract/schemas.js';
 type FileContentQuery = z.infer<typeof FileContentQuerySchema>;
 import type { PaginationInfo } from '../../../types/toolResults.js';
 import type { QueryWithPagination } from '../../../utils/response/groupedFinalizer.js';
-import type { GitHubFetchContentOutputLocal } from '../scheme.js';
 import type { WithOptionalMeta } from '../../../types/execution.js';
 export type PartialFileContentQuery = WithOptionalMeta<FileContentQuery> & QueryWithPagination;
 export type FileEntry = {
@@ -17,6 +16,7 @@ export type FileEntry = {
     totalLines?: number;
     sourceChars?: number;
     resolvedBranch?: string;
+    commitSha?: string;
     pagination?: PaginationInfo;
     isPartial?: boolean;
     startLine?: number;
@@ -40,13 +40,26 @@ export type FileContentNextMap = {
         tool: 'ghGetFileContent';
         query: Record<string, unknown>;
     };
+    continueLines?: {
+        tool: 'ghGetFileContent';
+        query: Record<string, unknown>;
+        why: string;
+        confidence: 'exact';
+    };
     cloneForSemantics?: {
         tool: 'ghCloneRepo';
         query: Record<string, unknown>;
         why: string;
         confidence: 'exact';
     };
+    escalateToClone?: {
+        tool: 'ghCloneRepo';
+        query: Record<string, unknown>;
+        why: string;
+        confidence: 'exact';
+    };
 };
+export type DirectoryPartialReason = keyof NonNullable<DirectoryEntry['skipped']> | 'providerDirectoryIncomplete';
 export type DirectoryEntry = {
     path: string;
     localPath: string;
@@ -84,19 +97,9 @@ export type DirectoryEntry = {
     }>;
     cached?: boolean;
     resolvedBranch?: string;
+    isPartial?: boolean;
+    terminalLimit?: boolean;
+    partialReasons?: DirectoryPartialReason[];
+    next?: Pick<FileContentNextMap, 'escalateToClone'>;
 };
-export type RepoGroup = {
-    id: string;
-    owner: string;
-    repo: string;
-    files?: FileEntry[];
-    directories?: DirectoryEntry[];
-};
-export type RepoGroupData = {
-    owner: string;
-    repo: string;
-    files?: FileEntry[];
-    directories?: DirectoryEntry[];
-};
-export type FileContentResponse = GitHubFetchContentOutputLocal;
 export {};

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { CharPagination, ItemPagination, ToolContinuation } from '../../scheme/pagination.js';
-import type { ResponsePaginationInfo } from '../../types/toolOutput.js';
+import type { BulkToolResultRow, 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>;
@@ -28,16 +28,14 @@ export declare const FileContentQueryLocalSchema: z.ZodObject<{
         standard: "standard";
         symbols: "symbols";
     }>>;
-    id: z.ZodOptional<z.ZodString>;
-    mainResearchGoal: z.ZodOptional<z.ZodString>;
-    researchGoal: z.ZodOptional<z.ZodString>;
+    goal: z.ZodOptional<z.ZodString>;
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const FileContentBulkQueryLocalSchema: z.ZodObject<{
     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>;
+}, z.core.$strict>;
 export type GitHubFetchFilePagination = (CharPagination & {
     nextPage?: number;
 }) | (ItemPagination & {
@@ -55,6 +53,7 @@ export interface GitHubFetchFileEntry {
     totalLines?: number;
     sourceChars?: number;
     resolvedBranch?: string;
+    commitSha?: string;
     pagination?: GitHubFetchFilePagination;
     next?: Record<string, ToolContinuation>;
     isPartial?: boolean;
@@ -78,6 +77,10 @@ export interface GitHubFetchDirectoryEntry {
     fileCount: number;
     totalSize: number;
     complete?: boolean;
+    verified?: boolean;
+    commitSha?: string;
+    hasSubdirectories?: boolean;
+    skippedSummary?: Record<string, number>;
     directoryEntryCount?: number;
     eligibleFileCount?: number;
     savedFileCount?: number;
@@ -104,6 +107,10 @@ export interface GitHubFetchDirectoryEntry {
     }>;
     cached?: boolean;
     resolvedBranch?: string;
+    isPartial?: boolean;
+    terminalLimit?: boolean;
+    partialReasons?: string[];
+    next?: Record<string, ToolContinuation>;
 }
 export interface GitHubFetchContentData {
     owner: string;
@@ -111,20 +118,16 @@ export interface GitHubFetchContentData {
     files?: GitHubFetchFileEntry[];
     directories?: GitHubFetchDirectoryEntry[];
 }
+export interface GitHubFetchContentErrorData {
+    owner?: string;
+    repo?: string;
+    path?: string;
+    error: string;
+}
 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;
-    }>;
+    results: Array<BulkToolResultRow<GitHubFetchContentData | GitHubFetchContentErrorData>>;
     [key: string]: unknown;
 }

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

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { FileContentQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { FileContentQuerySchema } from '../../toolContract/schemas.js';
 import type { MinifyMode } from '../../scheme/fields.js';
 type FileContentQuery = z.infer<typeof FileContentQuerySchema>;
 import type { PaginationInfo } from '../../types/toolResults.js';
@@ -61,8 +61,8 @@ export interface DirectoryFetchResult {
     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;
+    /** Immutable commit identity used by repoRoot and localPath. */
+    commitSha: string;
     /** true when nonFile > 0 — subdirectory entries were present but not fetched; use ghCloneRepo for full coverage */
     hasSubdirectories?: boolean;
     directoryEntryCount: number;
@@ -101,5 +101,6 @@ export interface FileMaterializationResult {
     owner: string;
     repo: string;
     branch: string;
+    commitSha: string;
 }
 export {};

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

@@ -0,0 +1,4 @@
+import type { CallToolResult } from '@modelcontextprotocol/server';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+import { type GitHubSearchQuery } from './scheme.js';
+export declare function executeGitHubSearch(args: ToolExecutionArgs<GitHubSearchQuery>): Promise<CallToolResult>;

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

@@ -0,0 +1,3 @@
+import type { BulkFinalizer } from '../../types/bulk.js';
+import type { GitHubSearchQuery } from './scheme.js';
+export declare function buildGitHubSearchFinalizer(): BulkFinalizer<GitHubSearchQuery>;