@octocodeai/octocode-tools-core 16.2.0

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

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

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const NpmSearchQueryLocalSchema: z.ZodObject<{
+    packageName: z.ZodString;
+    page: z.ZodDefault<z.ZodNumber>;
+    id: z.ZodOptional<z.ZodString>;
+    mainResearchGoal: z.ZodOptional<z.ZodString>;
+    researchGoal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const NpmSearchBulkQueryLocalSchema: z.ZodObject<{
+    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;
+export declare const NpmSearchOutputLocalSchema: z.ZodObject<{
+    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        data: z.ZodOptional<z.ZodObject<{
+            packages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                license: z.ZodOptional<z.ZodString>;
+                weeklyDownloads: z.ZodOptional<z.ZodNumber>;
+                repository: z.ZodOptional<z.ZodString>;
+                repositoryDirectory: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+            pagination: z.ZodOptional<z.ZodObject<{
+                currentPage: z.ZodNumber;
+                totalPages: z.ZodNumber;
+                perPage: z.ZodNumber;
+                totalFound: z.ZodNumber;
+                returned: z.ZodNumber;
+                hasMore: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        status: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    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>>;
+}, z.core.$strip>;

package/dist/tools/providerExecution.d.ts

@@ -0,0 +1,51 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { ProcessedBulkResult } from '../types/toolResults.js';
+import { type ICodeHostProvider, type ProviderCapabilities, type ProviderResponse, type ProviderType } from '../providers/types.js';
+interface ProviderExecutionContext {
+    providerType: ProviderType;
+    provider: ICodeHostProvider;
+    capabilities: ProviderCapabilities;
+    baseUrl?: string;
+    token?: string;
+    authInfo?: AuthInfo;
+}
+export declare class ProviderInitializationError extends Error {
+    readonly providerType: ProviderType;
+    constructor(providerType: ProviderType, message: string);
+}
+interface ProviderOperationSpec<TMeta, TData> {
+    meta: TMeta;
+    operation: () => Promise<ProviderResponse<TData>>;
+}
+interface ProviderOperationSuccess<TMeta, TData> {
+    meta: TMeta;
+    response: ProviderResponse<TData> & {
+        data: TData;
+    };
+}
+interface ProviderOperationFailure<TMeta, TData> {
+    meta: TMeta;
+    response: ProviderResponse<TData>;
+}
+export type ProviderOperationResult<TMeta, TData> = ProviderOperationSuccess<TMeta, TData> | ProviderOperationFailure<TMeta, TData>;
+export declare function createProviderExecutionContext(authInfo?: AuthInfo): ProviderExecutionContext;
+export declare function createLazyProviderContext(authInfo?: AuthInfo): () => ProviderExecutionContext;
+export declare function providerSupports(context: Pick<ProviderExecutionContext, 'capabilities'>, capability: keyof ProviderCapabilities): boolean;
+export declare function executeProviderOperation<TQuery extends {
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+}, TData>(query: TQuery, operation: () => Promise<ProviderResponse<TData>>): Promise<{
+    ok: true;
+    response: ProviderResponse<TData> & {
+        data: TData;
+    };
+} | {
+    ok: false;
+    result: ProcessedBulkResult;
+}>;
+export declare function executeProviderOperations<TMeta, TData>(operations: Array<ProviderOperationSpec<TMeta, TData>>, providerType?: ProviderType): Promise<{
+    successes: Array<ProviderOperationSuccess<TMeta, TData>>;
+    failures: Array<ProviderOperationFailure<TMeta, TData>>;
+}>;
+export {};

package/dist/tools/providerMappers.d.ts

@@ -0,0 +1,277 @@
+import type { CodeSearchResult, FileContentResult as ProviderFileContentResult, PullRequestSearchResult as ProviderPullRequestSearchResult, RepoSearchResult as ProviderRepoSearchResult, RepoStructureResult as ProviderRepoStructureResult } from '../providers/types.js';
+import type { z } from 'zod';
+import type { GitHubCodeSearchQuerySchema, GitHubReposSearchSingleQuerySchema, GitHubViewRepoStructureQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { GitHubPullRequestSearchQueryLocalSchema } from './github_search_pull_requests/scheme.js';
+import type { GitHubRepositoryOutput } from '@octocodeai/octocode-core/extra-types';
+import type { WithOptionalMeta } from '../types/execution.js';
+import { FileContentQueryLocalSchema } from './github_fetch_content/scheme.js';
+type GitHubCodeSearchQuery = z.infer<typeof GitHubCodeSearchQuerySchema>;
+type LocalFileContentQuery = z.infer<typeof FileContentQueryLocalSchema> & {
+    minify: import('../scheme/fields.js').MinifyMode;
+};
+type GitHubPullRequestSearchQuery = z.infer<typeof GitHubPullRequestSearchQueryLocalSchema>;
+type GitHubReposSearchSingleQuery = z.infer<typeof GitHubReposSearchSingleQuerySchema>;
+type GitHubViewRepoStructureQuery = z.infer<typeof GitHubViewRepoStructureQuerySchema>;
+type PRDefaultKeys = 'order' | 'limit' | 'page';
+type PartialPRQuery = WithOptionalMeta<Omit<GitHubPullRequestSearchQuery, PRDefaultKeys> & Partial<Pick<GitHubPullRequestSearchQuery, PRDefaultKeys>>>;
+type PartialRepoStructureQuery = WithOptionalMeta<GitHubViewRepoStructureQuery>;
+export declare function buildPaginationHints(pagination: {
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    entriesPerPage?: number;
+    perPage?: number;
+    totalMatches?: number;
+    reportedTotalMatches?: number;
+    reachableTotalMatches?: number;
+    totalMatchesKind?: 'exact' | 'reported' | 'lowerBound';
+    totalMatchesCapped?: boolean;
+}, label: string): string[];
+export declare function mapCodeSearchToolQuery(query: WithOptionalMeta<GitHubCodeSearchQuery>): {
+    keywords: string[];
+    projectId: string;
+    owner: string;
+    path: string;
+    filename: string;
+    extension: string;
+    language: string | undefined;
+    match: "path" | "file";
+    limit: number | undefined;
+    page: number;
+    mainResearchGoal: string;
+    researchGoal: string;
+    reasoning: string;
+};
+export interface CodeSearchGroupedMatch {
+    path: string;
+    value?: string;
+    pathOnly?: boolean;
+    matchIndices?: Array<{
+        start: number;
+        end: number;
+        lineOffset: number;
+    }>;
+    url?: string;
+}
+export interface CodeSearchGroupedResult {
+    id: string;
+    queryId?: string;
+    owner: string;
+    repo: string;
+    matches: CodeSearchGroupedMatch[];
+}
+export interface CodeSearchPagination {
+    currentPage: number;
+    totalPages: number;
+    perPage: number;
+    totalMatches: number;
+    reportedTotalMatches?: number;
+    reachableTotalMatches?: number;
+    totalMatchesKind?: 'exact' | 'reported' | 'lowerBound';
+    totalMatchesCapped?: boolean;
+    hasMore: boolean;
+    uniqueFileCount?: number;
+}
+export interface CodeSearchFlatResult {
+    results: CodeSearchGroupedResult[];
+    pagination?: CodeSearchPagination;
+    nonExistentScope?: boolean;
+}
+export declare function mapCodeSearchProviderResult(data: CodeSearchResult, query: WithOptionalMeta<GitHubCodeSearchQuery>): CodeSearchFlatResult;
+export declare function mapRepoSearchToolQuery(query: WithOptionalMeta<GitHubReposSearchSingleQuery>): {
+    keywords: string[];
+    topics: string[];
+    owner: string;
+    stars: string;
+    size: string;
+    created: string;
+    updated: string;
+    language: string;
+    archived: boolean | undefined;
+    visibility: "public" | "private" | undefined;
+    forks: string | undefined;
+    license: string | undefined;
+    goodFirstIssues: string | undefined;
+    match: ("name" | "description" | "readme")[];
+    sort: "stars" | "forks" | "updated" | "created" | "best-match" | undefined;
+    limit: number | undefined;
+    page: number;
+    mainResearchGoal: string;
+    researchGoal: string;
+    reasoning: string;
+};
+export declare function mapRepoSearchProviderRepositories(repositories: ProviderRepoSearchResult['repositories']): GitHubRepositoryOutput[];
+export declare function mapPullRequestToolQuery(query: PartialPRQuery): {
+    projectId: string;
+    owner: string;
+    query: string;
+    number: number;
+    state: "open" | "closed" | "merged" | "all" | undefined;
+    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: string;
+    reactions: string;
+    interactions: string;
+    draft: boolean;
+    match: ("comments" | "title" | "body")[];
+    archived: boolean | undefined;
+    content: unknown;
+    reviewMode: "summary" | "full";
+    filePage: number;
+    commentPage: number;
+    commitPage: number;
+    itemsPerPage: number;
+    sort: "created" | "updated" | "best-match" | "comments" | "reactions" | undefined;
+    order: "asc" | "desc" | undefined;
+    limit: number;
+    page: number;
+    charOffset: number;
+    charLength: number;
+    mainResearchGoal: string;
+    researchGoal: string;
+    reasoning: string;
+};
+export declare function mapPullRequestProviderResultData(data: ProviderPullRequestSearchResult, options?: {
+    includeFileChanges?: boolean;
+}): {
+    pullRequests: {
+        sanitizationWarnings?: string[];
+        fileChanges?: {
+            path: string;
+            status: string;
+            additions: number;
+            deletions: number;
+            patch?: string;
+        }[];
+        reviewSummary: {
+            totalComments: number;
+            inlineComments: number;
+            discussionComments: number;
+            commenters: string[];
+            latestCommentAt?: string;
+            themes: string[];
+        };
+        commits: {
+            sha: string;
+            message: string;
+            author: string;
+            date: string;
+        }[];
+        reviews: {
+            id: string;
+            user: string;
+            state: string;
+            body: string;
+            submittedAt?: string;
+            commitId?: string;
+        }[];
+        comments: {
+            bodyPagination: {
+                charOffset: number;
+                charLength: number;
+                totalChars: number;
+                hasMore: boolean;
+                nextCharOffset?: number;
+            };
+            id: string;
+            author: string;
+            body: string;
+            createdAt: string;
+            updatedAt: string;
+            commentType?: "discussion" | "review_inline";
+            path?: string;
+            line?: number;
+            in_reply_to_id?: number;
+        }[];
+        url: string;
+        state: "closed" | "open" | "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;
+        bodyPagination: {
+            charOffset: number;
+            charLength: number;
+            totalChars: number;
+            hasMore: boolean;
+            nextCharOffset?: number;
+        };
+        number: number;
+        title: string;
+        body: string;
+    }[];
+    resultData: Record<string, unknown>;
+    pagination: {
+        hasMore: boolean;
+        uniqueFileCount?: number;
+        totalMatchesCapped?: boolean;
+        totalMatchesKind?: "exact" | "reported" | "lowerBound";
+        reachableTotalMatches?: number;
+        reportedTotalMatches?: number;
+        totalMatches?: number;
+        currentPage: number;
+        totalPages: number;
+        perPage: number;
+    };
+};
+export declare function mapFileContentToolQuery(query: LocalFileContentQuery): {
+    projectId: string;
+    path: string;
+    ref: string;
+    startLine: number;
+    endLine: number;
+    matchString: string;
+    contextLines: number;
+    fullContent: boolean;
+    charOffset: number;
+    charLength: number;
+    minify: "none" | "standard" | "symbols";
+    matchStringIsRegex: boolean;
+    matchStringCaseSensitive: boolean;
+    mainResearchGoal: string;
+    researchGoal: string;
+    reasoning: string;
+};
+export declare function mapFileContentProviderResult(data: ProviderFileContentResult, query: WithOptionalMeta<LocalFileContentQuery>): Record<string, unknown>;
+export declare function mapRepoStructureToolQuery(query: PartialRepoStructureQuery, resolvedBranch: string): {
+    projectId: string;
+    ref: string;
+    path: string;
+    depth: number;
+    itemsPerPage: number;
+    page: number;
+    includeSizes: boolean;
+    mainResearchGoal: string;
+    researchGoal: string;
+    reasoning: string;
+};
+export declare function mapRepoStructureProviderResult(data: ProviderRepoStructureResult, _query: PartialRepoStructureQuery, filteredStructure: ProviderRepoStructureResult['structure'], resolvedBranch: string): Record<string, unknown>;
+export {};

package/dist/tools/toolConfig.d.ts

@@ -0,0 +1,41 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type z } from 'zod';
+import { DEFAULT_TOOL_METADATA_GATEWAY, type ToolMetadataGateway } from './toolMetadata/gateway.js';
+export type { ToolMetadataGateway };
+export { DEFAULT_TOOL_METADATA_GATEWAY };
+export type { ToolInvocationCallback } from '../types/toolResults.js';
+export type ToolDirectSecurity = 'basic' | 'remote';
+export interface ToolDirectExecutionConfig {
+    schema: z.ZodType;
+    inputSchema: z.ZodType;
+    executionFn: (input: never) => Promise<CallToolResult>;
+    security: ToolDirectSecurity;
+    requiresServerRuntime?: boolean;
+    requiresProviders?: boolean;
+}
+export interface ToolConfig {
+    name: string;
+    description: string;
+    isDefault: boolean;
+    isLocal: boolean;
+    isClone?: boolean;
+    isBinary?: boolean;
+    type: 'search' | 'content' | 'history' | 'debug';
+    skipMetadataCheck?: boolean;
+    direct: ToolDirectExecutionConfig;
+}
+export declare const getDescription: (toolName: string, gateway?: Pick<ToolMetadataGateway, "getDescription">) => string;
+export declare const GITHUB_SEARCH_CODE: ToolConfig;
+export declare const GITHUB_FETCH_CONTENT: ToolConfig;
+export declare const GITHUB_VIEW_REPO_STRUCTURE: ToolConfig;
+export declare const GITHUB_SEARCH_REPOSITORIES: ToolConfig;
+export declare const GITHUB_SEARCH_PULL_REQUESTS: ToolConfig;
+export declare const PACKAGE_SEARCH: ToolConfig;
+export declare const GITHUB_CLONE_REPO: ToolConfig;
+export declare const LOCAL_RIPGREP: ToolConfig;
+export declare const LOCAL_VIEW_STRUCTURE: ToolConfig;
+export declare const LOCAL_FIND_FILES: ToolConfig;
+export declare const LOCAL_FETCH_CONTENT: ToolConfig;
+export declare const LSP_GET_SEMANTIC_CONTENT: ToolConfig;
+export declare const LOCAL_BINARY_INSPECT: ToolConfig;
+export declare const ALL_TOOLS: ToolConfig[];

package/dist/tools/toolMetadata/baseSchema.d.ts

@@ -0,0 +1,2 @@
+import type { CompleteMetadata } from '@octocodeai/octocode-core/types';
+export declare const BASE_SCHEMA: CompleteMetadata["baseSchema"];

package/dist/tools/toolMetadata/descriptions.d.ts

@@ -0,0 +1 @@
+export declare const DESCRIPTIONS: Record<string, string>;

package/dist/tools/toolMetadata/gateway.d.ts

@@ -0,0 +1,7 @@
+import type { ToolNames } from '@octocodeai/octocode-core/types';
+export interface ToolMetadataGateway {
+    hasTool(toolName: string): boolean;
+    getDescription(toolName: string): string;
+    getToolName<TKey extends keyof ToolNames>(key: TKey): ToolNames[TKey];
+}
+export declare const DEFAULT_TOOL_METADATA_GATEWAY: ToolMetadataGateway;

package/dist/tools/toolMetadata/metadataPresence.d.ts

@@ -0,0 +1 @@
+export declare function isToolInMetadata(toolName: string): boolean;

package/dist/tools/toolMetadata/names.d.ts

@@ -0,0 +1,2 @@
+import type { CompleteMetadata } from '@octocodeai/octocode-core/types';
+export declare const TOOL_NAMES: CompleteMetadata["toolNames"];

package/dist/tools/toolMetadata/proxies.d.ts

@@ -0,0 +1,10 @@
+export { TOOL_NAMES } from './names.js';
+export { DESCRIPTIONS } from './descriptions.js';
+export { isToolInMetadata } from './metadataPresence.js';
+export { BASE_SCHEMA } from './baseSchema.js';
+type HintsMap = Record<string, readonly string[]>;
+export declare const TOOL_HINTS: Record<string, HintsMap>;
+export declare const GENERIC_ERROR_HINTS: readonly string[];
+export declare function getToolHintsSync(toolName: string, status: string): readonly string[];
+export declare function getDynamicHints(toolName: string, key: string): readonly string[];
+export declare function getGenericErrorHintsSync(): readonly string[];

package/dist/tools/toolMetadata/state.d.ts

@@ -0,0 +1,5 @@
+import type { CompleteMetadata } from '@octocodeai/octocode-core/types';
+export declare function loadToolContent(): Promise<CompleteMetadata>;
+export declare function initializeToolMetadata(): Promise<void>;
+export declare function getMetadataOrNull(): CompleteMetadata | null;
+export declare function _resetMetadataState(): void;

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

@@ -0,0 +1,2 @@
+import type { ToolNames } from '@octocodeai/octocode-core/types';
+export type ToolName = ToolNames[keyof ToolNames];

package/dist/tools/toolNames.d.ts

@@ -0,0 +1,2 @@
+export declare const STATIC_TOOL_NAMES: import("@octocodeai/octocode-core/types").ToolNames;
+export declare function isLocalTool(toolName: string): boolean;

package/dist/tools/utils.d.ts

@@ -0,0 +1,27 @@
+import type { ToolErrorResult, ToolSuccessResult, ToolInvocationCallback } from '../types/toolResults.js';
+import type { HintContext } from '../types/metadata.js';
+import type { ProviderResponse } from '../providers/types.js';
+import { createErrorResult } from '../utils/response/error.js';
+export { createErrorResult };
+export declare function invokeCallbackSafely(callback: ToolInvocationCallback | undefined, toolName: string, queries: unknown[]): Promise<void>;
+interface SuccessResultOptions {
+    hintContext?: HintContext;
+    prefixHints?: string[];
+    extraHints?: string[];
+    rawResponse?: unknown;
+}
+export declare function createSuccessResult<T extends object>(_query: {
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+}, data: T, hasContent: boolean, toolName: string, options?: SuccessResultOptions): ToolSuccessResult & T;
+export declare function handleProviderError(apiResult: ProviderResponse<unknown>, query: {
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+}): ToolErrorResult;
+export declare function handleCatchError(error: unknown, query: {
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+}, contextMessage?: string, toolName?: string): ToolErrorResult;

package/dist/types/bulk.d.ts

@@ -0,0 +1,41 @@
+import type { FlatQueryResult } from './toolResults.js';
+export interface BulkFinalizerInput<TQuery, TOutput extends Record<string, unknown> = Record<string, unknown>> {
+    queries: TQuery[];
+    results: FlatQueryResult[];
+    config: BulkResponseConfig<TQuery, TOutput>;
+}
+export interface BulkFinalizerOutput<TOutput extends Record<string, unknown> = Record<string, unknown>> {
+    structuredContent: TOutput;
+    text: string;
+    isError?: boolean;
+}
+export type BulkFinalizer<TQuery, TOutput extends Record<string, unknown> = Record<string, unknown>> = (input: BulkFinalizerInput<TQuery, TOutput>) => BulkFinalizerOutput<TOutput>;
+export interface BulkResponsePagination {
+    responseCharOffset?: number;
+    responseCharLength?: number;
+}
+export interface ResponsePaginationInfo {
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    charOffset: number;
+    charLength: number;
+    totalChars: number;
+    nextCharOffset?: number;
+}
+export interface BulkResponseConfig<TQuery = object, TOutput extends Record<string, unknown> = Record<string, unknown>> {
+    toolName: string;
+    keysPriority?: string[];
+    peerHints?: boolean;
+    concurrency?: number;
+    minQueryTimeoutMs?: number;
+    responsePagination?: BulkResponsePagination;
+    finalize?: BulkFinalizer<TQuery, TOutput>;
+}
+export interface BulkToolResponse {
+    results: FlatQueryResult[];
+    hints?: string[];
+    base?: string;
+    shared?: Record<string, string | number | boolean>;
+    responsePagination?: ResponsePaginationInfo;
+}

package/dist/types/execution.d.ts

@@ -0,0 +1,11 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { HintContext } from './metadata.js';
+export type WithOptionalMeta<T> = Partial<T>;
+export interface ToolExecutionArgs<TQuery> {
+    queries: TQuery[];
+    responseCharOffset?: number;
+    responseCharLength?: number;
+    authInfo?: AuthInfo;
+    sessionId?: string;
+    hintContext?: HintContext;
+}

package/dist/types/metadata.d.ts

@@ -0,0 +1,69 @@
+export type HintStatus = 'empty' | 'error';
+export interface HintContext {
+    fileSize?: number;
+    resultSize?: number;
+    tokenEstimate?: number;
+    entryCount?: number;
+    matchCount?: number;
+    fileCount?: number;
+    isLarge?: boolean;
+    errorType?: 'size_limit' | 'not_found' | 'directory' | 'permission' | 'pattern_too_broad' | 'symbol_not_found' | 'file_not_found' | 'timeout' | 'not_a_function' | 'rate_limit' | 'lsp_unavailable';
+    originalError?: string;
+    status?: number;
+    isRateLimited?: boolean;
+    retryAfter?: number;
+    rateLimitRemaining?: number;
+    hasPattern?: boolean;
+    hasPagination?: boolean;
+    path?: string;
+    hasOwnerRepo?: boolean;
+    match?: 'file' | 'path';
+    searchEngine?: 'rg' | 'grep';
+    wasFilteredToEmpty?: boolean;
+    hasConfigFiles?: boolean;
+    owner?: string;
+    repo?: string;
+    branch?: string;
+    extension?: string;
+    filename?: string;
+    keywords?: string[];
+    state?: string;
+    author?: string;
+    query?: string;
+    prNumber?: number;
+    locationCount?: number;
+    hasExternalPackage?: boolean;
+    isFallback?: boolean;
+    searchRadius?: number;
+    lineHint?: number;
+    symbolName?: string;
+    uri?: string;
+    hasMultipleFiles?: boolean;
+    hasMorePages?: boolean;
+    currentPage?: number;
+    totalPages?: number;
+    direction?: 'incoming' | 'outgoing';
+    callCount?: number;
+    depth?: number;
+    hasMoreContent?: boolean;
+    isPartial?: boolean;
+    endLine?: number;
+    totalLines?: number;
+    nextCharOffset?: number;
+    totalChars?: number;
+    filteredAll?: boolean;
+    matchedPaths?: string[];
+    totalMatches?: number;
+    hasMore?: boolean;
+    flagFiles?: string[];
+    language?: string;
+    topic?: string;
+    prMatch?: string[];
+    type?: string;
+}
+type HintGenerator = (context: HintContext) => (string | undefined)[];
+export interface ToolHintGenerators {
+    empty: HintGenerator;
+    error: HintGenerator;
+}
+export {};

package/dist/types/promise.d.ts

@@ -0,0 +1,12 @@
+export interface PromiseResult<T> {
+    success: boolean;
+    data?: T;
+    error?: Error;
+    index: number;
+}
+export interface PromiseExecutionOptions {
+    timeout?: number;
+    continueOnError?: boolean;
+    concurrency?: number;
+    onError?: (error: Error, index: number) => void;
+}