@octocodeai/octocode-tools-core 16.2.0

package/dist/providers/capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderCapabilities, ProviderType } from './types.js';
+export declare const PROVIDER_CAPABILITIES: Record<ProviderType, ProviderCapabilities>;

package/dist/providers/factory.d.ts

@@ -0,0 +1,9 @@
+import type { ICodeHostProvider, ProviderType, ProviderConfig } from './types.js';
+export declare function getProvider(type?: ProviderType, config?: ProviderConfig): ICodeHostProvider;
+export declare function clearProviderCache(): void;
+export interface ProviderDiagnostic {
+    provider: string;
+    ok: boolean;
+    error?: string;
+}
+export declare function initializeProviders(): Promise<ProviderDiagnostic[]>;

package/dist/providers/github/GitHubProvider.d.ts

@@ -0,0 +1,14 @@
+import type { ICodeHostProvider, ProviderConfig, ProviderResponse, CodeSearchQuery, CodeSearchResult, FileContentQuery, FileContentResult, RepoSearchQuery, RepoSearchResult, PullRequestQuery, PullRequestSearchResult, RepoStructureQuery, RepoStructureResult } from '../types.js';
+export declare class GitHubProvider implements ICodeHostProvider {
+    readonly type: "github";
+    readonly capabilities: import("../types.js").ProviderCapabilities;
+    private authInfo?;
+    constructor(config?: ProviderConfig);
+    searchCode(query: CodeSearchQuery): Promise<ProviderResponse<CodeSearchResult>>;
+    getFileContent(query: FileContentQuery): Promise<ProviderResponse<FileContentResult>>;
+    searchRepos(query: RepoSearchQuery): Promise<ProviderResponse<RepoSearchResult>>;
+    searchPullRequests(query: PullRequestQuery): Promise<ProviderResponse<PullRequestSearchResult>>;
+    getRepoStructure(query: RepoStructureQuery): Promise<ProviderResponse<RepoStructureResult>>;
+    resolveDefaultBranch(projectId: string): Promise<string>;
+    private handleError;
+}

package/dist/providers/github/githubContent.d.ts

@@ -0,0 +1,9 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { ProviderResponse, FileContentQuery, FileContentResult } from '../types.js';
+import type { GitHubFileContentApiData } from '../../tools/github_fetch_content/types.js';
+export { parseGitHubProjectId } from './utils.js';
+export declare function transformFileContentResult(data: GitHubFileContentApiData, query: FileContentQuery): FileContentResult;
+export declare function getFileContent(query: FileContentQuery, authInfo?: AuthInfo, parseProjectId?: (projectId?: string) => {
+    owner?: string;
+    repo?: string;
+}): Promise<ProviderResponse<FileContentResult>>;

package/dist/providers/github/githubPullRequests.d.ts

@@ -0,0 +1,12 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { ProviderResponse, PullRequestQuery, PullRequestSearchResult } from '../types.js';
+import type { GitHubPullRequestSearchApiData } from '../../tools/github_search_pull_requests/types.js';
+export { parseGitHubProjectId } from './utils.js';
+export declare function transformPullRequestResult(data: GitHubPullRequestSearchApiData, query: PullRequestQuery, parseProjectId?: (projectId?: string) => {
+    owner?: string;
+    repo?: string;
+}): PullRequestSearchResult;
+export declare function searchPullRequests(query: PullRequestQuery, authInfo?: AuthInfo, parseProjectId?: (projectId?: string) => {
+    owner?: string;
+    repo?: string;
+}): Promise<ProviderResponse<PullRequestSearchResult>>;

package/dist/providers/github/githubSearch.d.ts

@@ -0,0 +1,12 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { ProviderResponse, CodeSearchQuery, CodeSearchResult, RepoSearchQuery, RepoSearchResult } from '../types.js';
+import type { GitHubSearchRepositoriesData } from '@octocodeai/octocode-core/extra-types';
+import type { OptimizedCodeSearchResult } from '../../github/githubAPI.js';
+export { parseGitHubProjectId } from './utils.js';
+export declare function transformCodeSearchResult(data: OptimizedCodeSearchResult): CodeSearchResult;
+export declare function transformRepoSearchResult(data: GitHubSearchRepositoriesData): RepoSearchResult;
+export declare function searchCode(query: CodeSearchQuery, authInfo?: AuthInfo, parseProjectId?: (projectId?: string) => {
+    owner?: string;
+    repo?: string;
+}): Promise<ProviderResponse<CodeSearchResult>>;
+export declare function searchRepos(query: RepoSearchQuery, authInfo?: AuthInfo): Promise<ProviderResponse<RepoSearchResult>>;

package/dist/providers/github/githubStructure.d.ts

@@ -0,0 +1,9 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { ProviderResponse, RepoStructureQuery, RepoStructureResult } from '../types.js';
+import type { GitHubRepositoryStructureResult } from '../../tools/github_view_repo_structure/types.js';
+export { parseGitHubProjectId } from './utils.js';
+export declare function transformRepoStructureResult(data: GitHubRepositoryStructureResult): RepoStructureResult;
+export declare function getRepoStructure(query: RepoStructureQuery, authInfo?: AuthInfo, parseProjectId?: (projectId?: string) => {
+    owner?: string;
+    repo?: string;
+}): Promise<ProviderResponse<RepoStructureResult>>;

package/dist/providers/github/utils.d.ts

@@ -0,0 +1,10 @@
+import type { GitHubAPIError } from '../../github/githubAPI.js';
+import type { ProviderResponse } from '../types.js';
+type GitHubProviderErrorSource = Pick<GitHubAPIError, 'error'> & Partial<Pick<GitHubAPIError, 'status' | 'hints' | 'rateLimitRemaining' | 'rateLimitReset' | 'retryAfter'>>;
+export declare function parseGitHubProjectId(projectId?: string): {
+    owner?: string;
+    repo?: string;
+};
+export declare function createGitHubProviderError(apiError: GitHubProviderErrorSource): ProviderResponse<never>;
+export declare function createGitHubProviderErrorFromResult(result: unknown): ProviderResponse<never> | null;
+export {};

package/dist/providers/providerQueries.d.ts

@@ -0,0 +1,111 @@
+type ProviderType = 'github';
+interface BaseProviderQuery {
+    provider?: ProviderType;
+    id?: string;
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+}
+export interface CodeSearchQuery extends BaseProviderQuery {
+    keywords: string[];
+    projectId?: string;
+    owner?: string;
+    path?: string;
+    filename?: string;
+    extension?: string;
+    language?: string;
+    match?: 'file' | 'path';
+    limit?: number;
+    page?: number;
+}
+export interface FileContentQuery extends BaseProviderQuery {
+    projectId: string;
+    path: string;
+    ref?: string;
+    startLine?: number;
+    endLine?: number;
+    matchString?: string;
+    contextLines?: number;
+    matchStringIsRegex?: boolean;
+    matchStringCaseSensitive?: boolean;
+    charOffset?: number;
+    charLength?: number;
+    fullContent?: boolean;
+    minify: 'none' | 'standard' | 'symbols';
+}
+export interface RepoSearchQuery extends BaseProviderQuery {
+    keywords?: string[];
+    topics?: string[];
+    owner?: string;
+    minStars?: number;
+    stars?: string;
+    size?: string;
+    created?: string;
+    updated?: string;
+    language?: string;
+    match?: Array<'name' | 'description' | 'readme'>;
+    archived?: boolean;
+    visibility?: 'public' | 'private';
+    forks?: string;
+    license?: string;
+    goodFirstIssues?: string;
+    sort?: 'stars' | 'forks' | 'updated' | 'created' | 'best-match';
+    order?: 'asc' | 'desc';
+    limit?: number;
+    page?: number;
+}
+export interface PullRequestQuery extends BaseProviderQuery {
+    projectId?: string;
+    owner?: string;
+    repo?: string;
+    query?: string;
+    number?: number;
+    state?: 'open' | 'closed' | 'merged' | 'all';
+    author?: string;
+    assignee?: string;
+    commenter?: string;
+    involves?: string;
+    mentions?: string;
+    reviewRequested?: string;
+    reviewedBy?: string;
+    labels?: string[];
+    noLabel?: boolean;
+    noMilestone?: boolean;
+    noProject?: boolean;
+    noAssignee?: boolean;
+    baseBranch?: string;
+    headBranch?: string;
+    created?: string;
+    updated?: string;
+    closed?: string;
+    mergedAt?: string;
+    comments?: number | string;
+    reactions?: number | string;
+    interactions?: number | string;
+    draft?: boolean;
+    match?: Array<'title' | 'body' | 'comments'>;
+    archived?: boolean;
+    content?: unknown;
+    reviewMode?: 'summary' | 'full';
+    filePage?: number;
+    commentPage?: number;
+    commitPage?: number;
+    itemsPerPage?: number;
+    sort?: 'created' | 'updated' | 'best-match' | 'comments' | 'reactions';
+    order?: 'asc' | 'desc';
+    limit?: number;
+    page?: number;
+    charOffset?: number;
+    charLength?: number;
+}
+export interface RepoStructureQuery extends BaseProviderQuery {
+    projectId: string;
+    ref?: string;
+    path?: string;
+    depth?: number;
+    recursive?: boolean;
+    itemsPerPage?: number;
+    page?: number;
+    includeSizes?: boolean;
+}
+export {};

package/dist/providers/providerResults.d.ts

@@ -0,0 +1,175 @@
+import type { PaginationInfo } from '../types/toolResults.js';
+export interface UnifiedRepository {
+    id: string;
+    name: string;
+    fullPath: string;
+    description: string | null;
+    url: string;
+    cloneUrl: string;
+    defaultBranch: string;
+    stars: number;
+    forks: number;
+    visibility: 'public' | 'private' | 'internal';
+    topics: string[];
+    createdAt: string;
+    updatedAt: string;
+    lastActivityAt: string;
+    openIssuesCount?: number;
+    archived?: boolean;
+    language?: string;
+}
+export interface CodeSearchItem {
+    path: string;
+    matches: Array<{
+        context: string;
+        positions: [number, number][];
+    }>;
+    url: string;
+    repository: {
+        id: string;
+        name: string;
+        url: string;
+    };
+    lastModifiedAt?: string;
+}
+export interface CodeSearchResult {
+    items: CodeSearchItem[];
+    totalCount: number;
+    pagination: PaginationInfo;
+    repositoryContext?: {
+        owner: string;
+        repo: string;
+        branch?: string;
+    };
+    nonExistentScope?: boolean;
+}
+export interface FileContentResult {
+    path: string;
+    content: string;
+    encoding: 'utf-8' | 'base64';
+    size: number;
+    totalLines?: number;
+    sourceChars?: number;
+    sourceBytes?: number;
+    contentView?: 'none' | 'standard' | 'symbols';
+    isSkeleton?: boolean;
+    ref: string;
+    lastModified?: string;
+    lastModifiedBy?: string;
+    lastCommitSha?: string;
+    pagination?: PaginationInfo;
+    isPartial?: boolean;
+    startLine?: number;
+    endLine?: number;
+    matchRanges?: Array<{
+        start: number;
+        end: number;
+    }>;
+    warnings?: string[];
+    matchNotFound?: boolean;
+    searchedFor?: string;
+}
+export interface RepoSearchResult {
+    repositories: UnifiedRepository[];
+    totalCount: number;
+    pagination: PaginationInfo;
+    nonExistentScope?: boolean;
+}
+export interface PullRequestItem {
+    number: number;
+    title: string;
+    body: string | null;
+    bodyPagination?: {
+        charOffset: number;
+        charLength: number;
+        totalChars: number;
+        hasMore: boolean;
+        nextCharOffset?: number;
+    };
+    url: string;
+    state: 'open' | 'closed' | 'merged';
+    draft: boolean;
+    author: string;
+    assignees: string[];
+    labels: string[];
+    sourceBranch: string;
+    targetBranch: string;
+    sourceSha?: string;
+    targetSha?: string;
+    createdAt: string;
+    updatedAt: string;
+    closedAt?: string;
+    mergedAt?: string;
+    commentsCount?: number;
+    changedFilesCount?: number;
+    additions?: number;
+    deletions?: number;
+    comments?: Array<{
+        id: string;
+        author: string;
+        body: string;
+        createdAt: string;
+        updatedAt: string;
+        bodyPagination?: {
+            charOffset: number;
+            charLength: number;
+            totalChars: number;
+            hasMore: boolean;
+            nextCharOffset?: number;
+        };
+        commentType?: 'discussion' | 'review_inline';
+        path?: string;
+        line?: number;
+        in_reply_to_id?: number;
+    }>;
+    reviews?: Array<{
+        id: string;
+        user: string;
+        state: string;
+        body: string;
+        submittedAt?: string;
+        commitId?: string;
+    }>;
+    commits?: Array<{
+        sha: string;
+        message: string;
+        author: string;
+        date: string;
+    }>;
+    fileChanges?: Array<{
+        path: string;
+        status: string;
+        additions: number;
+        deletions: number;
+        patch?: string;
+    }>;
+    sanitizationWarnings?: string[];
+}
+export interface PullRequestSearchResult {
+    items: PullRequestItem[];
+    totalCount: number;
+    pagination: PaginationInfo;
+    repositoryContext?: {
+        owner: string;
+        repo: string;
+    };
+}
+export interface DirectoryEntry {
+    files: string[];
+    folders: string[];
+}
+export interface RepoStructureResult {
+    projectPath: string;
+    branch: string;
+    defaultBranch?: string;
+    path: string;
+    structure: Record<string, DirectoryEntry>;
+    fileSizeMap?: Record<string, Record<string, number>>;
+    summary: {
+        totalFiles: number;
+        totalFolders: number;
+        truncated: boolean;
+    };
+    pagination?: PaginationInfo;
+    hints?: string[];
+}

package/dist/providers/types.d.ts

@@ -0,0 +1,48 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+export type { CodeSearchQuery, FileContentQuery, RepoSearchQuery, PullRequestQuery, RepoStructureQuery, } from './providerQueries.js';
+export type { UnifiedRepository, CodeSearchItem, CodeSearchResult, FileContentResult, RepoSearchResult, PullRequestItem, PullRequestSearchResult, DirectoryEntry, RepoStructureResult, } from './providerResults.js';
+import type { CodeSearchQuery, FileContentQuery, RepoSearchQuery, PullRequestQuery, RepoStructureQuery } from './providerQueries.js';
+import type { CodeSearchResult, FileContentResult, RepoSearchResult, PullRequestSearchResult, RepoStructureResult } from './providerResults.js';
+export type ProviderType = 'github';
+export interface ProviderConfig {
+    type: ProviderType;
+    baseUrl?: string;
+    token?: string;
+    authInfo?: AuthInfo;
+}
+export interface ProviderCapabilities {
+    cloneRepo: boolean;
+    fetchDirectoryToDisk: boolean;
+    requiresScopedCodeSearch: boolean;
+    supportsMergedState: boolean;
+    supportsMultiTopicSearch: boolean;
+}
+export interface ProviderResponse<T> {
+    data?: T;
+    error?: string;
+    status: number;
+    provider: ProviderType;
+    hints?: string[];
+    rateLimit?: {
+        remaining: number;
+        reset: number;
+        retryAfter?: number;
+    };
+    rawResponseChars?: number;
+}
+export interface ICodeHostProvider {
+    readonly type: ProviderType;
+    readonly capabilities: ProviderCapabilities;
+    searchCode(query: CodeSearchQuery): Promise<ProviderResponse<CodeSearchResult>>;
+    getFileContent(query: FileContentQuery): Promise<ProviderResponse<FileContentResult>>;
+    searchRepos(query: RepoSearchQuery): Promise<ProviderResponse<RepoSearchResult>>;
+    searchPullRequests(query: PullRequestQuery): Promise<ProviderResponse<PullRequestSearchResult>>;
+    getRepoStructure(query: RepoStructureQuery): Promise<ProviderResponse<RepoStructureResult>>;
+    resolveDefaultBranch(projectId: string): Promise<string>;
+}
+export declare function isProviderSuccess<T>(response: ProviderResponse<T>): response is ProviderResponse<T> & {
+    data: T;
+};
+export declare function isProviderError<T>(response: ProviderResponse<T>): response is ProviderResponse<T> & {
+    error: string;
+};

package/dist/responses.d.ts

@@ -0,0 +1,47 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types';
+import type { BulkToolResponse } from './types/bulk.js';
+import type { StructuredToolResponse } from './types/toolResults.js';
+import type { RoleContentBlock, RoleBasedResultOptions } from './types/responseTypes.js';
+export { StatusEmojis } from './types/responseTypes.js';
+export type { ContentRole, RoleContentBlock, RoleBasedResultOptions, RoleAnnotations, } from './types/responseTypes.js';
+export type CallToolResultOutputMode = 'text' | 'json';
+export declare function createResult(options: {
+    data: unknown;
+    instructions?: string;
+    isError?: boolean;
+}): CallToolResult;
+export declare const ContentBuilder: {
+    system(text: string, priority?: number): RoleContentBlock;
+    assistant(text: string, priority?: number): RoleContentBlock;
+    user(text: string, priority?: number): RoleContentBlock;
+    data(data: unknown, format?: "yaml" | "json"): RoleContentBlock;
+};
+export declare const StatusEmoji: {
+    readonly success: "✅";
+    readonly empty: "📭";
+    readonly error: "❌";
+    readonly partial: "⚠️";
+    readonly searching: "🔍";
+    readonly loading: "⏳";
+    readonly info: "ℹ️";
+    readonly file: "📄";
+    readonly folder: "📁";
+    readonly page: "📃";
+    readonly definition: "🎯";
+    readonly reference: "🔗";
+    readonly call: "📞";
+};
+export declare function createRoleBasedResult(options: RoleBasedResultOptions): CallToolResult;
+export declare const QuickResult: {
+    success(summary: string, data: unknown, hints?: string[]): CallToolResult;
+    empty(message: string, hints?: string[]): CallToolResult;
+    error(error: string, details?: unknown): CallToolResult;
+    paginated(summary: string, data: unknown, pagination: {
+        page: number;
+        total: number;
+        hasMore: boolean;
+    }, hints?: string[]): CallToolResult;
+};
+export declare function sanitizeStructuredContent(obj: unknown): unknown;
+export declare function formatCallToolResultForOutput(result: Pick<CallToolResult, 'content' | 'structuredContent' | 'isError'>, outputMode: CallToolResultOutputMode): string;
+export declare function createResponseFormat(responseData: StructuredToolResponse | BulkToolResponse, keysPriority?: string[]): string;

package/dist/scheme/coreSchemas.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+type AnyZodObject = z.ZodObject<z.ZodRawShape>;
+export type QueryShape = Record<string, z.ZodTypeAny>;
+export declare function describeQuerySchema<T extends AnyZodObject>(coreSchema: T, overrides?: QueryShape, options?: {
+    strict?: boolean;
+}): T;
+export declare function createQueryShapeSchema<T extends AnyZodObject>(coreSchema: T, overrides?: QueryShape, options?: {
+    strict?: boolean;
+}): AnyZodObject;
+export {};

package/dist/scheme/fields.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare function clampedInt(min: number, max: number): z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+export type MinifyMode = 'none' | 'standard' | 'symbols';
+export declare const relaxedPageNumberField: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
+export declare const contextLinesField: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+export declare const lineNumberField: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+export declare function createRelaxedBulkQuerySchema(querySchema: z.ZodTypeAny, options?: {
+    maxQueries?: number;
+}): 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>;

package/dist/scheme/responseEnvelope.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const responseEnvelopeFields: {
+    readonly hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    readonly base: z.ZodOptional<z.ZodString>;
+    readonly shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    readonly responsePagination: z.ZodOptional<z.ZodObject<{
+        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>>;
+};
+export declare function withResponseEnvelope<S extends z.ZodObject>(schema: S): S;

package/dist/security/bridge.d.ts

@@ -0,0 +1,10 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+export declare function withSecurityValidation<T extends Record<string, unknown>>(toolName: string, toolHandler: (sanitizedArgs: T, authInfo?: AuthInfo, sessionId?: string) => Promise<CallToolResult>): (args: unknown, extra: {
+    authInfo?: AuthInfo;
+    sessionId?: string;
+    signal?: AbortSignal;
+}) => Promise<CallToolResult>;
+export declare function withBasicSecurityValidation<T extends object>(toolHandler: (sanitizedArgs: T) => Promise<CallToolResult>, toolName?: string): (args: unknown, extra?: {
+    signal?: AbortSignal;
+}) => Promise<CallToolResult>;

package/dist/serverConfig.d.ts

@@ -0,0 +1,23 @@
+import type { ProviderType } from './providers/types.js';
+import { resolveTokenFull } from 'octocode-shared';
+import type { ServerConfig, TokenSourceType } from './types/server.js';
+type ResolveTokenFullFn = typeof resolveTokenFull;
+export declare function _setTokenResolvers(resolvers: {
+    resolveTokenFull?: ResolveTokenFullFn;
+}): void;
+export declare function _resetTokenResolvers(): void;
+export declare function initialize(): Promise<void>;
+export declare function cleanup(): void;
+export declare function getServerConfig(): ServerConfig;
+export declare function getGitHubToken(): Promise<string | null>;
+export declare function isLocalEnabled(): boolean;
+export declare function isCloneEnabled(): boolean;
+export declare function isLoggingEnabled(): boolean;
+export declare function getTokenSource(): Promise<TokenSourceType>;
+export declare function getActiveProvider(): ProviderType;
+export declare function getActiveProviderConfig(): {
+    provider: ProviderType;
+    baseUrl?: string;
+    token?: string;
+};
+export {};

package/dist/session.d.ts

@@ -0,0 +1,25 @@
+import { type PersistedSession } from 'octocode-shared';
+import type { RateLimitData } from './types/session.js';
+declare class SessionManager {
+    private session;
+    private readonly logEndpoint;
+    constructor();
+    getSessionId(): string;
+    getSession(): PersistedSession;
+    logInit(): Promise<void>;
+    logToolCall(toolName: string, repos: string[], _mainResearchGoal?: string, _researchGoal?: string, _reasoning?: string): Promise<void>;
+    logError(toolName: string, errorCode: string): Promise<void>;
+    logRateLimit(data: RateLimitData): Promise<void>;
+    logPackageRegistryFailure(registry: string): void;
+    private sendLog;
+}
+export declare function initializeSession(): SessionManager;
+export declare function getSessionManager(): SessionManager | null;
+export declare function logSessionInit(): Promise<void>;
+export declare function logToolCall(toolName: string, repos: string[], mainResearchGoal?: string, researchGoal?: string, reasoning?: string): Promise<void>;
+export declare function logPromptCall(promptName: string): Promise<void>;
+export declare function logSessionError(toolName: string, errorCode: string): Promise<void>;
+export declare function logRateLimit(data: RateLimitData): Promise<void>;
+export declare function logPackageRegistryFailure(registry: string): void;
+export declare function resetSessionManager(): void;
+export {};

package/dist/tools/directToolCatalog.d.ts

@@ -0,0 +1,56 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+export type DirectToolInput = Record<string, unknown> & {
+    queries: unknown[];
+};
+export interface DirectToolDefinition {
+    name: string;
+    schema: z.ZodType;
+    inputSchema: z.ZodType;
+}
+export type DirectToolCategory = 'GitHub' | 'Local' | 'LSP' | 'Package' | 'Other';
+export declare const DIRECT_TOOL_CATEGORIES: readonly DirectToolCategory[];
+export interface DirectToolDisplayField {
+    name: string;
+    required: boolean;
+    type: string;
+    /** Numeric bounds and default, e.g. "1-100, default 30" — surfaced inline so
+     * agents see the full constraint without fetching the raw JSON schema. */
+    constraints?: string;
+    description?: string;
+}
+export interface DirectToolOutputField {
+    name: string;
+    type: string;
+    optional?: boolean;
+}
+export interface DirectToolMetadata {
+    tools?: Record<string, {
+        description?: string;
+        schema?: Record<string, string>;
+    }>;
+}
+export interface PrepareDirectToolInputOptions {
+    sourceLabel?: string;
+    onUnknownFields?: (unknownFields: string[], queryIndex: number) => void;
+}
+export declare class DirectToolInputError extends Error {
+    readonly details: string[];
+    constructor(message: string, details?: string[]);
+}
+export declare const DIRECT_TOOL_DEFINITIONS: DirectToolDefinition[];
+export declare function findDirectToolDefinition(name: string): DirectToolDefinition | undefined;
+export declare function getDirectToolCategory(toolName: string): DirectToolCategory;
+export declare function sortDirectToolNames(toolNames: string[]): string[];
+export declare function formatDirectToolSchemaText(toolName: string): string;
+export declare function formatDirectToolMetadataSchemaText(schema: Record<string, string> | undefined): string;
+export declare function getDirectToolAutoFilledFields(toolName: string): string[];
+export declare function getDirectToolOutputFields(): DirectToolOutputField[];
+export declare function formatDirectToolOutputSchemaText(): string;
+export declare function getDirectToolDescription(toolName: string, metadata?: DirectToolMetadata | null): string;
+export declare function getDirectToolDisplayFields(toolName: string): DirectToolDisplayField[];
+export declare function buildDirectToolExampleQuery(toolName: string): Record<string, unknown>;
+export declare function prepareDirectToolInputFromJsonText(toolName: string, inputText: string | undefined, options?: PrepareDirectToolInputOptions): DirectToolInput | null;
+export declare function prepareDirectToolInput(toolName: string, rawPayload: unknown, options?: PrepareDirectToolInputOptions): DirectToolInput;
+export declare function formatDirectToolValidationIssues(error: z.ZodError): string[];
+export declare function executeDirectTool(name: string, input: unknown): Promise<CallToolResult>;

package/dist/tools/executionGuard.d.ts

@@ -0,0 +1,14 @@
+import type { ProcessedBulkResult } from '../types/toolResults.js';
+interface GuardableQuery {
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+}
+interface ExecutionGuardOptions<TQuery extends GuardableQuery> {
+    toolName: string;
+    query: TQuery;
+    execute: () => Promise<ProcessedBulkResult>;
+    contextMessage?: string;
+}
+export declare function executeWithToolBoundary<TQuery extends GuardableQuery>({ toolName, query, execute, contextMessage, }: ExecutionGuardOptions<TQuery>): Promise<ProcessedBulkResult>;
+export {};