@octocodeai/octocode-tools-core 16.6.2 → 17.0.1

package/dist/tools/lsp/semantic_content/semanticFileOps/documentSymbols.d.ts

@@ -0,0 +1,27 @@
+import type { LSPRange } from '@octocodeai/octocode-engine/lsp/types';
+import { type LspGetSemanticsQuery, type LspSemanticEnvelope } from '../../shared/semanticTypes.js';
+export type CompactSymbol = {
+    name: string;
+    kind: string;
+    line: number;
+    character: number;
+    endLine: number;
+    childCount: number;
+    containerName?: string;
+};
+type LspPositionLike = {
+    line: number;
+    character: number;
+};
+export declare function getDocumentSymbols(query: LspGetSemanticsQuery): Promise<LspSemanticEnvelope | Record<string, unknown>>;
+export declare function flattenDocumentSymbols(symbols: readonly unknown[]): CompactSymbol[];
+export declare function flattenDocumentSymbol(value: unknown, output: CompactSymbol[], containerName?: string): void;
+export declare function getSymbolRange(value: {
+    range?: unknown;
+    location?: unknown;
+}): LSPRange | undefined;
+export declare function isLspRange(value: unknown): value is LSPRange;
+export declare function isPosition(value: unknown): value is LspPositionLike;
+export declare function countTopLevelDocumentSymbols(symbols: readonly unknown[]): number;
+export declare function countBy<T>(items: readonly T[], keyForItem: (item: T) => string): Record<string, number>;
+export {};

package/dist/tools/lsp/semantic_content/semanticFileOps/workspaceSymbolsAndDiagnostics.d.ts

@@ -0,0 +1,20 @@
+import type { LspSemanticEnvelope, DiagnosticSemanticQuery, WorkspaceSymbolSemanticQuery } from '../../shared/semanticTypes.js';
+import type { CompactSymbol } from './documentSymbols.js';
+type CompactWorkspaceSymbol = CompactSymbol & {
+    uri: string;
+};
+type DiagnosticItem = {
+    severity?: number;
+    message: string;
+    line: number;
+    endLine: number;
+    character: number;
+    code?: string | number;
+    source?: string;
+};
+export declare function getWorkspaceSymbols(query: WorkspaceSymbolSemanticQuery): Promise<LspSemanticEnvelope | Record<string, unknown>>;
+export declare function compactWorkspaceSymbols(raw: unknown[]): CompactWorkspaceSymbol[];
+export declare function getFileDiagnostics(query: DiagnosticSemanticQuery): Promise<LspSemanticEnvelope | Record<string, unknown>>;
+export declare function extractDiagnostics(raw: unknown): DiagnosticItem[];
+export declare function parseDiagnostic(item: unknown): DiagnosticItem[];
+export {};

package/dist/tools/lsp/semantic_content/semanticFileOps.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Barrel for the semanticFileOps/ split (anchor & workspace resolution vs.
+ * documentSymbols vs. workspaceSymbols/diagnostics operations). Kept so no
+ * other file in the repo needs to change its import path.
+ */
+export { isNativeJsTsFile, throwLspUnavailable, toLocalPath, workspaceSymbolAnchorExtensions, workspaceSymbolAnchorIncludeGlobs, findWorkspaceSymbolAnchorByName, resolveWorkspaceSymbolAnchor, lspErrorMessage, nativeDocumentSymbols, } from './semanticFileOps/anchor.js';
+export { type CompactSymbol, getDocumentSymbols, flattenDocumentSymbols, flattenDocumentSymbol, getSymbolRange, isLspRange, isPosition, countTopLevelDocumentSymbols, countBy, } from './semanticFileOps/documentSymbols.js';
+export { getWorkspaceSymbols, compactWorkspaceSymbols, getFileDiagnostics, extractDiagnostics, parseDiagnostic, } from './semanticFileOps/workspaceSymbolsAndDiagnostics.js';

package/dist/tools/lsp/semantic_content/semanticPresentation.d.ts

@@ -0,0 +1,53 @@
+import type { CallHierarchyItem, IncomingCall, LSPRange, OutgoingCall } from '@octocodeai/octocode-engine/lsp/types';
+import { type CompactLocation, type LspGetSemanticsQuery, type LspSemanticEnvelope } from '../shared/semanticTypes.js';
+export type CompactCallTarget = {
+    name: string;
+    kind: string;
+    uri: string;
+    line: number;
+    endLine: number;
+    selectionLine?: number;
+};
+export type CompactCall = {
+    direction: 'incoming' | 'outgoing';
+    item: CompactCallTarget;
+    ranges: Array<{
+        line: number;
+        character: number;
+    }>;
+    rangeCount: number;
+    rangeSampleCount: number;
+    contentPreview?: string;
+};
+export declare function attachSemanticRawEvidence<T extends object>(result: T): T;
+export declare function formatSemanticResult(query: LspGetSemanticsQuery, result: LspSemanticEnvelope | Record<string, unknown>): LspSemanticEnvelope | Record<string, unknown>;
+export declare function withSemanticNext(result: LspSemanticEnvelope | Record<string, unknown>): LspSemanticEnvelope | Record<string, unknown>;
+export declare function isSemanticEnvelope(value: LspSemanticEnvelope | Record<string, unknown>): value is LspSemanticEnvelope;
+export declare function compactSemanticEnvelope(envelope: LspSemanticEnvelope): LspSemanticEnvelope;
+export declare function compactSemanticPayload(payload: LspSemanticEnvelope['payload']): LspSemanticEnvelope['payload'];
+export declare function formatSymbolRow(value: unknown): string;
+export declare function formatLocationRow(location: CompactLocation | string): string;
+export declare function formatReferenceFileRow(value: unknown): string;
+export declare function formatCallRow(value: unknown): string;
+export declare function formatCallTargetRow(value: unknown): string;
+export declare function formatRangeRow(value: unknown): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function stringField(record: Record<string, unknown>, key: string, fallback?: string): string;
+export declare function numberField(record: Record<string, unknown>, key: string, fallback?: number): number;
+export declare function arrayField(record: Record<string, unknown>, key: string): unknown[];
+export declare function oneLine(value: string, maxLength: number): string;
+export declare function compactIncomingCall(call: IncomingCall & {
+    direction: 'incoming';
+}, contextLines: number): CompactCall;
+export declare function compactOutgoingCall(call: OutgoingCall & {
+    direction: 'outgoing';
+}, contextLines: number): CompactCall;
+export declare function compactCallItem(item: CallHierarchyItem): CompactCallTarget;
+export declare function compactRanges(ranges: readonly LSPRange[]): {
+    line: number;
+    character: number;
+}[];
+export declare function contentPreview(item: CallHierarchyItem, contextLines: number): {
+    contentPreview?: string;
+};
+export declare function symbolKindName(kind: unknown): string;

package/dist/tools/lsp/shared/readiness.d.ts

@@ -0,0 +1,17 @@
+import type { LspReadiness } from '@octocodeai/octocode-engine/lsp/types';
+import type { LspSemanticEnvelope, SemanticEmptyCategory } from './semanticTypes.js';
+/**
+ * The "server returned nothing" category of an envelope, whether the emptiness
+ * is expressed as an `empty`-kind payload (definition/hover) or a nested
+ * `empty` on an otherwise-shaped payload (references/callers). Returns
+ * `undefined` when the envelope carries real results.
+ */
+export declare function zeroResultEmptyCategory(envelope: LspSemanticEnvelope): SemanticEmptyCategory | undefined;
+/**
+ * Attach a caveat when a semantic query came back empty AND the language server
+ * never confirmed it finished indexing (readiness other than `progressIdle`).
+ * Without this, an agent reads a zero as "symbol is unused" when it may just be
+ * "server not indexed yet". `readiness === undefined` means the wait was
+ * skipped (servers that answer immediately) — those are trusted, no caveat.
+ */
+export declare function attachReadinessWarning(envelope: LspSemanticEnvelope, readiness: LspReadiness | undefined): LspSemanticEnvelope;

package/dist/tools/lsp/shared/semanticTypes.d.ts

@@ -161,4 +161,10 @@ export type LspSemanticEnvelope = {
     pagination?: unknown;
     warnings?: string[];
     hints?: string[];
+    next?: Record<string, {
+        tool: string;
+        query: Record<string, unknown>;
+        why?: string;
+        confidence?: 'exact' | 'heuristic';
+    }>;
 };

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

@@ -2,6 +2,7 @@ import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import type { z } from 'zod';
 import type { NpmPackageQuerySchema } from '@octocodeai/octocode-core/schemas';
 type NpmSearchQuery = z.input<typeof NpmPackageQuerySchema>;
+import type { PackageResult } from '../../utils/package/common.js';
 import type { ToolExecutionArgs } from '../../types/execution.js';
 type PackageData = {
     name: string;
@@ -13,6 +14,12 @@ type PackageData = {
     repositoryDirectory?: string;
     repositoryId?: string;
     next?: Record<string, unknown>;
+    warnings?: string[];
+    diagnostics?: Array<{
+        level: 'info' | 'warning' | 'error';
+        message: string;
+        code?: string;
+    }>;
 };
 type PackageRepositoryData = {
     repository: string;
@@ -25,6 +32,7 @@ type CompactPackageData = {
     packages: PackageData[];
     repositories?: Record<string, PackageRepositoryData>;
 };
+export declare function formatPackageData(pkg: PackageResult): PackageData;
 export declare function compactPackageRepositories(packages: PackageData[]): CompactPackageData;
 type PackagePagination = {
     currentPage: number;

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

@@ -25,28 +25,67 @@ export declare const NpmSearchOutputLocalSchema: z.ZodObject<{
                 repository: z.ZodOptional<z.ZodString>;
                 repositoryDirectory: z.ZodOptional<z.ZodString>;
                 repositoryId: z.ZodOptional<z.ZodString>;
-                next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                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>>>;
+                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>>>;
             }, z.core.$loose>>>;
             repositories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 repository: z.ZodString;
                 owner: z.ZodString;
                 repo: z.ZodString;
                 repositoryDirectory: z.ZodOptional<z.ZodString>;
-                next: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                next: 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>>;
             }, 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;
                 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>;
             }, z.core.$strip>>;
         }, z.core.$loose>>;
         status: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>>>;
-    hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     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<{

package/dist/tools/providerMappers/codeSearch.d.ts

@@ -0,0 +1,66 @@
+import type { CodeSearchResult } from '../../providers/types.js';
+import type { z } from 'zod';
+import type { GitHubCodeSearchQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { WithOptionalMeta } from '../../types/execution.js';
+type GitHubCodeSearchQuery = z.infer<typeof GitHubCodeSearchQuerySchema>;
+/**
+ * Char-boundary truncation mirroring the Rust engine's `truncate_unicode`:
+ * keeps at most `maxChars` Unicode scalars and appends `...` when it cuts.
+ * Never slices UTF-8 mid-codepoint or mid-token — the single data-layer bound
+ * for GitHub code-search match fragments (the render layer must not re-trim).
+ */
+export declare function truncateSnippetChars(value: string, maxChars?: number): string;
+export declare function mapCodeSearchToolQuery(query: WithOptionalMeta<GitHubCodeSearchQuery>): {
+    keywords: string[];
+    projectId: string;
+    owner: string;
+    path: string;
+    filename: string;
+    extension: string;
+    language: string | undefined;
+    match: "file" | "path";
+    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;
+    nextPage?: number;
+    uniqueFileCount?: number;
+}
+export interface CodeSearchFlatResult {
+    results: CodeSearchGroupedResult[];
+    pagination?: CodeSearchPagination;
+    nonExistentScope?: boolean;
+    incompleteResults?: boolean;
+}
+export declare function mapCodeSearchProviderResult(data: CodeSearchResult, query: WithOptionalMeta<GitHubCodeSearchQuery>): CodeSearchFlatResult;
+export {};

package/dist/tools/providerMappers/fileContent.d.ts

@@ -0,0 +1,28 @@
+import type { FileContentResult as ProviderFileContentResult } from '../../providers/types.js';
+import type { z } from 'zod';
+import type { WithOptionalMeta } from '../../types/execution.js';
+import { FileContentQueryLocalSchema } from '../github_fetch_content/scheme.js';
+type LocalFileContentQuery = z.infer<typeof FileContentQueryLocalSchema> & {
+    minify: import('../../scheme/fields.js').MinifyMode;
+};
+export declare function mapFileContentToolQuery(query: LocalFileContentQuery): {
+    projectId: string;
+    path: string;
+    ref: string;
+    startLine: number;
+    endLine: number;
+    matchString: string;
+    contextLines: number;
+    fullContent: boolean;
+    forceRefresh: 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 {};

package/dist/tools/providerMappers/pullRequests.d.ts

@@ -0,0 +1,158 @@
+import type { PullRequestSearchResult as ProviderPullRequestSearchResult } from '../../providers/types.js';
+import type { z } from 'zod';
+import type { GitHubPullRequestSearchQueryLocalSchema } from '../github_search_pull_requests/scheme.js';
+import type { WithOptionalMeta } from '../../types/execution.js';
+type GitHubPullRequestSearchQuery = z.infer<typeof GitHubPullRequestSearchQueryLocalSchema>;
+type PRDefaultKeys = 'order' | 'limit' | 'page';
+type PartialPRQuery = WithOptionalMeta<Omit<GitHubPullRequestSearchQuery, PRDefaultKeys> & Partial<Pick<GitHubPullRequestSearchQuery, PRDefaultKeys>>>;
+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: ("title" | "body" | "comments")[];
+    milestone: string;
+    language: string;
+    checks: "success" | "failure" | "pending";
+    review: "none" | "approved" | "changes_requested" | "required";
+    locked: boolean;
+    visibility: "public" | "private";
+    teamMentions: string;
+    project: string;
+    archived: boolean | undefined;
+    content: unknown;
+    reviewMode: "full" | "summary";
+    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: "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;
+        bodyPagination: {
+            charOffset: number;
+            charLength: number;
+            totalChars: number;
+            hasMore: boolean;
+            nextCharOffset?: number;
+        };
+        number: number;
+        title: string;
+        body: string;
+    }[];
+    resultData: Record<string, unknown>;
+    pagination: {
+        nextPage?: number;
+        hasMore: boolean;
+        uniqueFileCount?: number;
+        totalMatchesCapped?: boolean;
+        totalMatchesKind?: "exact" | "reported" | "lowerBound";
+        reachableTotalMatches?: number;
+        reportedTotalMatches?: number;
+        totalMatches?: number;
+        currentPage: number;
+        totalPages: number;
+        perPage: number;
+    };
+};
+export {};

package/dist/tools/providerMappers/repoSearch.d.ts

@@ -0,0 +1,30 @@
+import type { RepoSearchResult as ProviderRepoSearchResult } from '../../providers/types.js';
+import type { z } from 'zod';
+import type { GitHubReposSearchSingleQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { GitHubRepositoryOutput } from '@octocodeai/octocode-core/extra-types';
+import type { WithOptionalMeta } from '../../types/execution.js';
+type GitHubReposSearchSingleQuery = z.infer<typeof GitHubReposSearchSingleQuerySchema>;
+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: ("description" | "name" | "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 {};

package/dist/tools/providerMappers/repoStructure.d.ts

@@ -0,0 +1,20 @@
+import type { RepoStructureResult as ProviderRepoStructureResult } from '../../providers/types.js';
+import type { z } from 'zod';
+import type { GitHubViewRepoStructureQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { WithOptionalMeta } from '../../types/execution.js';
+type GitHubViewRepoStructureQuery = z.infer<typeof GitHubViewRepoStructureQuerySchema>;
+type PartialRepoStructureQuery = WithOptionalMeta<GitHubViewRepoStructureQuery>;
+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/providerMappers/shared.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Small helpers shared across the providerMappers/* domain files.
+ * Kept internal to the providerMappers module (not part of its public
+ * barrel contract) — imported directly by sibling files in this directory.
+ */
+export declare function toProviderProjectId(owner?: string, repo?: string): string | undefined;
+export declare function splitRepositoryPath(repositoryPath: string): {
+    owner: string;
+    repo: string;
+};
+export declare function countMetadata(pagination: {
+    reportedTotalMatches?: number;
+    reachableTotalMatches?: number;
+    totalMatchesKind?: 'exact' | 'reported' | 'lowerBound';
+    totalMatchesCapped?: boolean;
+    uniqueFileCount?: number;
+} | undefined): {
+    uniqueFileCount?: number;
+    totalMatchesCapped?: boolean;
+    totalMatchesKind?: "exact" | "reported" | "lowerBound";
+    reachableTotalMatches?: number;
+    reportedTotalMatches?: number;
+};