@oh-my-pi/pi-coding-agent 17.2.11 → 17.2.12

package/dist/types/tools/gh-common.d.ts

@@ -0,0 +1,69 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "./index.js";
+import type { GhToolDetails } from "./gh.js";
+import type { GhLabel, GhUser } from "./gh-types.js";
+export declare function normalizeText(value: string | null | undefined): string;
+export declare function normalizeBlock(value: string | null | undefined): string;
+export declare function looksLikeGitHubUrl(value: string | undefined): boolean;
+export declare function normalizeOptionalString(value: string | null | undefined): string | undefined;
+export declare function normalizePrIdentifierList(value: string | string[] | undefined): string[];
+export declare function requireNonEmpty(value: string | null | undefined, label: string): string;
+export declare function appendRepoFlag(args: string[], repo: string | undefined, identifier?: string): void;
+export declare const REPO_API_URL_PREFIX = "https://api.github.com/repos/";
+export declare const PR_URL_PATTERN: RegExp;
+export declare const ISSUE_URL_PATTERN: RegExp;
+export declare function requireCurrentGitBranch(cwd: string, signal?: AbortSignal): Promise<string>;
+export declare function requireCurrentGitHead(cwd: string, signal?: AbortSignal): Promise<string>;
+export declare function formatAuthor(author: GhUser | null | undefined): string | undefined;
+export declare function formatLabels(labels: GhLabel[] | undefined): string | undefined;
+export declare function pushLine(lines: string[], label: string, value: string | number | boolean | undefined): void;
+export declare function parsePullRequestUrl(value: string | undefined): {
+    repo?: string;
+    prNumber?: number;
+};
+/**
+ * Parse a digit-only decimal positive integer or return undefined. Rejects
+ * `1e2`, `0x10`, `12.0`, leading +/-, or any other shape `Number()` would
+ * accept — those would otherwise key the cache against the wrong row.
+ */
+export declare function parsePositiveDecimalInt(value: string | undefined): number | undefined;
+export declare function parseIssueUrl(value: string | undefined): {
+    repo?: string;
+    issueNumber?: number;
+};
+export declare function githubRepoSlugEquals(left: string | undefined, right: string): boolean;
+export declare function resolveGitHubRepo(cwd: string, repo: string | undefined, runRepo: string | undefined, signal?: AbortSignal): Promise<string>;
+/**
+ * Process-lifetime cache of `gh repo view --json nameWithOwner` lookups keyed
+ * by absolute cwd. Avoids repeated `gh` chatter when the same protocol handler
+ * or tool call resolves the default repo many times in a row.
+ *
+ * The shared lookup is intentionally **not** bound to any caller's
+ * AbortSignal. Cancelling one caller would otherwise kill the underlying
+ * `gh repo view` for every concurrent waiter on the same cwd. Each caller's
+ * signal is honored at the wait point via `untilAborted` instead, so an abort
+ * unwinds only that caller.
+ */
+export declare const DEFAULT_REPO_RESOLVED: Map<string, string>;
+export declare const DEFAULT_REPO_INFLIGHT: Map<string, Promise<string>>;
+export declare function resolveDefaultRepoMemoized(cwd: string, signal?: AbortSignal): Promise<string>;
+/**
+ * Best-effort cached cwd → `owner/repo` resolution that swallows any failure
+ * (not a git checkout, no GitHub remote, `gh` unauthenticated, …) into
+ * `undefined`. Use where the cwd repo is a convenience fallback, not a safety
+ * check.
+ */
+export declare function tryResolveCurrentRepo(cwd: string, signal: AbortSignal | undefined): Promise<string | undefined>;
+/**
+ * Best-effort fresh cwd → `owner/repo` resolution for safety checks that must
+ * reflect the repository currently mounted at `cwd`, not the process-lifetime
+ * default-repo cache.
+ */
+export declare function tryResolveCurrentRepoFresh(cwd: string, signal: AbortSignal | undefined): Promise<string | undefined>;
+export declare function saveArtifactText(session: ToolSession, toolType: string, text: string): Promise<string | undefined>;
+export declare function appendArtifactReference(text: string, artifactId: string | undefined, label: string): string;
+export declare function buildTextResult(text: string, sourceUrl?: string, details?: GhToolDetails, options?: {
+    artifactId?: string;
+    artifactLabel?: string;
+    useless?: boolean;
+}): AgentToolResult<GhToolDetails>;

package/dist/types/tools/gh-pr-checkout.d.ts

@@ -0,0 +1,84 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as git from "../utils/git.js";
+import type { ToolSession } from "./index.js";
+import type { GhPrCheckoutSummary, GhToolDetails } from "./gh.js";
+import type { GhPrViewData, GhRepoViewData, GithubInput } from "./gh-types.js";
+export declare const GH_REPO_CLONE_FIELDS: string[];
+export declare const GH_PR_CHECKOUT_FIELDS: string[];
+export declare function sanitizeRemoteName(value: string): string;
+/** Maximum disambiguation suffixes we try before giving up on a worktree path. */
+export declare const WORKTREE_PATH_MAX_SUFFIX = 100;
+export declare function toLocalBranchRef(value: string): string;
+export declare function requireGitRepoRoot(cwd: string, signal?: AbortSignal): Promise<string>;
+export declare function requirePrimaryGitRepoRoot(cwd: string, signal?: AbortSignal): Promise<string>;
+/**
+ * Resolve a worktree path that is free of conflicts.
+ *
+ * Given a `basePath`, return either `basePath` itself or `${basePath}-2`,
+ * `${basePath}-3`, … up to {@link WORKTREE_PATH_MAX_SUFFIX} — whichever is the
+ * first variant that is **not** registered with git as another worktree and
+ * **not** present on disk. The numeric tail salvages two rare cases that
+ * would otherwise abort a checkout: stale leftover dirs from an interrupted
+ * `git worktree add`, and the (vanishingly unlikely) `hashPath` collision
+ * between two repos that happen to produce the same 7-hex digest.
+ */
+export declare function resolveAvailableWorktreePath(basePath: string, existingWorktrees: git.GitWorktreeEntry[]): Promise<string>;
+export declare function selectPrCloneUrl(originUrl: string | undefined, repo: Pick<GhRepoViewData, "url" | "sshUrl">): string;
+export declare function getRemoteUrls(repoRoot: string, signal?: AbortSignal): Promise<Map<string, string>>;
+export declare function ensurePrRemote(repoRoot: string, data: GhPrViewData, signal?: AbortSignal): Promise<{
+    name: string;
+    url: string;
+}>;
+export declare function resolvePrBranchPushTarget(repoRoot: string, localBranch: string, signal?: AbortSignal): Promise<{
+    remoteName: string;
+    remoteBranch: string;
+    remoteUrl?: string;
+    prUrl?: string;
+    maintainerCanModify?: boolean;
+    isCrossRepository: boolean;
+}>;
+export declare function formatPrCheckoutResult(options: {
+    data: GhPrViewData;
+    localBranch: string;
+    worktreePath: string;
+    remoteName: string;
+    remoteUrl: string;
+    reused: boolean;
+}): string;
+export declare function formatPrPushResult(options: {
+    localBranch: string;
+    remoteName: string;
+    remoteBranch: string;
+    remoteUrl?: string;
+    prUrl?: string;
+    forceWithLease: boolean;
+}): string;
+export declare function joinSections(sections: string[]): string[];
+export declare function executePrCheckout(session: ToolSession, params: GithubInput, signal: AbortSignal | undefined): Promise<AgentToolResult<GhToolDetails>>;
+export interface PrCheckoutOptions {
+    prRef: string | undefined;
+    repo: string | undefined;
+    force: boolean;
+}
+export interface PrCheckoutOutcome {
+    data: GhPrViewData;
+    localBranch: string;
+    worktreePath: string;
+    remoteName: string;
+    remoteUrl: string;
+    headRefName: string;
+    reused: boolean;
+}
+export declare function checkoutPullRequest(session: ToolSession, signal: AbortSignal | undefined, options: PrCheckoutOptions): Promise<PrCheckoutOutcome>;
+export declare function outcomeToSummary(outcome: PrCheckoutOutcome): GhPrCheckoutSummary;
+export declare function executePrPush(session: ToolSession, params: GithubInput, signal: AbortSignal | undefined): Promise<AgentToolResult<GhToolDetails>>;
+export declare function executePrCreate(session: ToolSession, params: GithubInput, signal: AbortSignal | undefined): Promise<AgentToolResult<GhToolDetails>>;
+export declare function formatPrCreateResult(options: {
+    url: string;
+    prNumber?: number;
+    data?: GhPrViewData;
+    title?: string;
+    base?: string;
+    head?: string;
+    draft?: boolean;
+}): string;

package/dist/types/tools/gh-pr-diff.d.ts

@@ -0,0 +1,102 @@
+import type { Settings } from "../config/settings.js";
+import type { ViewLookupResult } from "./gh-view.js";
+export declare const PR_DIFF_FILES_PAGE_SIZE = 100;
+export declare const PR_DIFF_FILES_MAX = 3000;
+export interface PrDiffFile {
+    /** Display path. Prefers the post-image (`b/<path>`) when present. */
+    path: string;
+    additions: number;
+    deletions: number;
+    changeType: "modified" | "added" | "deleted" | "renamed" | "binary";
+    /** Pre-image path for renames/deletes; same as `path` otherwise. */
+    oldPath?: string;
+    /** Byte offset of the section's `diff --git` line in the unified diff. */
+    startOffset: number;
+    /** Byte offset of the next section (or end-of-text). */
+    endOffset: number;
+}
+export interface PrDiffPayload {
+    /** Full unified diff text as returned by `gh pr diff --color never`. */
+    unified: string;
+    files: PrDiffFile[];
+}
+export interface PrDiffLookupOptions {
+    cwd: string;
+    repo: string;
+    number: number;
+    signal?: AbortSignal;
+    settings?: Settings;
+    cacheAuthKey?: string | null;
+}
+/**
+ * Split `gh pr diff` output on `^diff --git ` boundaries and parse per-file
+ * metadata. The unified diff is preserved verbatim so callers can slice it by
+ * byte offsets without re-running gh.
+ */
+export declare function parsePrUnifiedDiff(text: string): PrDiffPayload;
+export interface ParsedDiffHeaderToken {
+    value: string;
+    nextIndex: number;
+}
+export declare function skipDiffHeaderSpaces(text: string, index: number): number;
+export declare function parseDiffQuotedEscape(text: string, slashIndex: number): ParsedDiffHeaderToken;
+export declare function parseDiffQuotedToken(text: string, startIndex: number): ParsedDiffHeaderToken | undefined;
+export declare function parseDiffHeaderToken(text: string, startIndex: number): ParsedDiffHeaderToken | undefined;
+export declare function stripPrDiffPathPrefix(value: string, prefix: "a/" | "b/"): string | undefined;
+export declare function parsePrDiffHeaderPaths(header: string): {
+    oldPath?: string;
+    newPath?: string;
+};
+export declare function isPrDiffFileHeaderLine(line: string): boolean;
+export declare function parsePrDiffSection(section: string, startOffset: number, endOffset: number): PrDiffFile;
+/**
+ * A single entry from `GET /repos/{owner}/{repo}/pulls/{n}/files`. `patch` is
+ * absent for binary files and for individual file diffs GitHub deems too large
+ * to render.
+ */
+export interface GhPrFileApi {
+    filename?: string;
+    previous_filename?: string;
+    status?: string;
+    additions?: number;
+    deletions?: number;
+    patch?: string;
+}
+export interface GhPrApi {
+    changed_files?: number;
+}
+/**
+ * GitHub rejects the aggregate PR diff endpoint with HTTP 406 once the diff
+ * exceeds 20,000 lines. Detect that specific failure so the caller can fall
+ * back to the per-file endpoint instead of aborting the whole review.
+ */
+export declare function isPrDiffTooLargeError(err: unknown): boolean;
+export declare function formatSyntheticDiffPath(prefix: "a/" | "b/", path: string): string;
+/**
+ * Reconstruct a `diff --git` section from a single files-API entry. The API's
+ * `patch` field carries only the hunk body, so the `diff --git`/`---`/`+++`
+ * headers are synthesized to match `gh pr diff` output — this keeps
+ * {@link parsePrUnifiedDiff} and the review parser producing identical section
+ * boundaries and byte offsets. Files whose `patch` is omitted (binary or
+ * too-large) stay visible with an explicit marker rather than being dropped.
+ */
+export declare function buildSyntheticDiffSection(file: GhPrFileApi): string | undefined;
+/**
+ * Fallback PR diff retrieval via the paginated per-file endpoint, used when the
+ * aggregate `gh pr diff` is rejected for exceeding GitHub's 20,000-line limit.
+ * The per-file patches are not subject to that aggregate cap, so even very
+ * large PRs can be reassembled into a synthetic unified diff.
+ */
+export declare function fetchPrDiffViaFilesApi(cwd: string, repo: string, number: number, signal: AbortSignal | undefined): Promise<string>;
+export declare function fetchPrDiffFresh(cwd: string, repo: string, number: number, signal: AbortSignal | undefined): Promise<{
+    rendered: string;
+    sourceUrl: string | undefined;
+    payload: PrDiffPayload;
+}>;
+/**
+ * Cache-aware PR diff fetcher. Stores the full unified diff plus a parsed
+ * file index in a single `pr-diff` cache row so the listing, full-diff, and
+ * per-file slice variants of `pr://<n>/diff` share one `gh pr diff`
+ * invocation.
+ */
+export declare function getOrFetchPrDiff(options: PrDiffLookupOptions): Promise<ViewLookupResult<PrDiffPayload>>;

package/dist/types/tools/gh-run-watch.d.ts

@@ -0,0 +1,78 @@
+import type { AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "./index.js";
+import type { GhRunWatchFailedLogDetails, GhRunWatchJobDetails, GhRunWatchRunDetails, GhRunWatchViewDetails, GhToolDetails } from "./gh.js";
+import type { GhActionsJobApi, GhActionsRunApi, GhFailedJobLog, GhRunJobSnapshot, GhRunReference, GhRunSnapshot, GithubInput } from "./gh-types.js";
+export declare const RUN_WATCH_INTERVAL_DEFAULT = 3;
+export declare const RUN_WATCH_INTERVAL_SLOW = 15;
+export declare const RUN_WATCH_FAST_WINDOW_MS = 60000;
+export declare const RUN_WATCH_NO_RUNS_GIVE_UP_MS = 90000;
+export declare const RUN_WATCH_MAX_POLL_FAILURES = 5;
+export declare const RUN_WATCH_GRACE_DEFAULT = 5;
+export declare const RUN_WATCH_TAIL_DEFAULT = 15;
+export declare const RUN_WATCH_TAIL_MAX = 200;
+export declare const RUN_JOBS_PAGE_SIZE = 100;
+export declare function resolveTailLimit(value: number | undefined): number;
+export declare const RUN_URL_PATTERN: RegExp;
+export declare const RUN_SUCCESS_CONCLUSIONS: Set<string>;
+export declare const RUN_FAILURE_CONCLUSIONS: Set<string>;
+export declare const JOB_FAILURE_CONCLUSIONS: Set<string>;
+export declare function parseRunReference(value: string | undefined): GhRunReference;
+export declare function normalizeRunJob(job: GhActionsJobApi): GhRunJobSnapshot | null;
+export declare function normalizeRunSnapshot(run: GhActionsRunApi, jobs: GhRunJobSnapshot[]): GhRunSnapshot;
+export declare function getRunOutcome(value: string | undefined): "success" | "failure" | "pending";
+export declare function getRunSnapshotOutcome(run: GhRunSnapshot): "success" | "failure" | "pending";
+export declare function getRunCollectionOutcome(runs: GhRunSnapshot[]): "success" | "failure" | "pending";
+export declare function getRunCollectionSignature(runs: GhRunSnapshot[]): string;
+export declare function isFailedJob(job: GhRunJobSnapshot): boolean;
+export declare const GH_RATE_LIMIT_ERROR_PATTERN: RegExp;
+/**
+ * Rate-limit / secondary-limit gh failures are transient; the run_watch poll
+ * loops back off and retry them instead of discarding the whole watch.
+ */
+export declare function isRateLimitedGhError(err: unknown): boolean;
+export declare function formatJobState(job: GhRunJobSnapshot): string;
+export declare function parseTimestampMs(value: string | undefined): number | undefined;
+export declare function getJobDurationSeconds(job: GhRunJobSnapshot, observedAtMs: number): number | undefined;
+export declare function buildRunWatchJobDetails(job: GhRunJobSnapshot, observedAtMs: number): GhRunWatchJobDetails;
+export declare function buildRunWatchRunDetails(run: GhRunSnapshot, observedAtMs: number): GhRunWatchRunDetails;
+export declare function buildFailedLogDetails(failedJobLogs: GhFailedJobLog[]): GhRunWatchFailedLogDetails[];
+export declare function renderJobsSection(jobs: GhRunJobSnapshot[]): string[];
+export declare function renderFailedJobLogs(failedJobLogs: GhFailedJobLog[], options: {
+    mode: "tail";
+    tail: number;
+} | {
+    mode: "full";
+}): string[];
+export declare function renderRunSection(run: GhRunSnapshot): string[];
+export declare function formatRunWatchSnapshot(repo: string, run: GhRunSnapshot, pollCount: number, note?: string, includeOutcome?: boolean): string;
+export declare function formatRunWatchResult(repo: string, run: GhRunSnapshot, failedJobLogs: GhFailedJobLog[], tail: number, options?: {
+    mode?: "tail" | "full";
+}): string;
+export declare function formatCommitRunWatchSnapshot(repo: string, headSha: string, branch: string | undefined, runs: GhRunSnapshot[], pollCount: number, note?: string): string;
+export declare function formatCommitRunWatchResult(repo: string, headSha: string, branch: string | undefined, runs: GhRunSnapshot[], failedJobLogs: GhFailedJobLog[], tail: number, options?: {
+    mode?: "tail" | "full";
+}): string;
+export declare function buildGhDetails(repo: string, run: GhRunSnapshot): GhToolDetails;
+export declare function buildRunWatchDetails(repo: string, run: GhRunSnapshot, options?: {
+    state?: GhRunWatchViewDetails["state"];
+    pollCount?: number;
+    note?: string;
+    failedJobLogs?: GhFailedJobLog[];
+}): GhToolDetails;
+export declare function buildGhRunCollectionDetails(repo: string, headSha: string, branch: string | undefined, runs: GhRunSnapshot[]): GhToolDetails;
+export declare function buildCommitRunWatchDetails(repo: string, headSha: string, branch: string | undefined, runs: GhRunSnapshot[], options?: {
+    state?: GhRunWatchViewDetails["state"];
+    pollCount?: number;
+    note?: string;
+    failedJobLogs?: GhFailedJobLog[];
+}): GhToolDetails;
+export declare function resolveGitHubBranchHead(cwd: string, repo: string, branch: string, signal?: AbortSignal): Promise<string>;
+export declare function fetchRunsForCommit(cwd: string, repo: string, headSha: string, signal?: AbortSignal, completedRunJobsCache?: Map<number, GhRunJobSnapshot[]>): Promise<GhRunSnapshot[]>;
+export declare function fetchRunJobs(cwd: string, repo: string, runId: number, signal?: AbortSignal): Promise<GhRunJobSnapshot[]>;
+export declare function fetchRunSnapshot(cwd: string, repo: string, runId: number, signal?: AbortSignal): Promise<GhRunSnapshot>;
+export declare function tailLogLines(log: string, tail: number): string | undefined;
+export declare function fetchFailedJobLogs(cwd: string, repo: string, failedJobs: Array<{
+    run: GhRunSnapshot;
+    job: GhRunJobSnapshot;
+}>, tail: number, signal?: AbortSignal): Promise<GhFailedJobLog[]>;
+export declare function executeRunWatch(session: ToolSession, toolName: string, params: GithubInput, signal: AbortSignal | undefined, onUpdate: AgentToolUpdateCallback<GhToolDetails> | undefined): Promise<AgentToolResult<GhToolDetails>>;

package/dist/types/tools/gh-search.d.ts

@@ -0,0 +1,61 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "./index.js";
+import type { GhToolDetails } from "./gh.js";
+import type { GhApiLabel, GhApiSearchCodeItem, GhApiSearchCommitItem, GhApiSearchIssueItem, GhApiSearchRepoItem, GhApiUser, GhLabel, GhSearchCodeResult, GhSearchCommitResult, GhSearchRepoResult, GhSearchResult, GhUser, GithubInput } from "./gh-types.js";
+export declare const SEARCH_LIMIT_DEFAULT = 10;
+export declare const SEARCH_LIMIT_MAX = 50;
+export declare const FILE_PREVIEW_LIMIT = 50;
+export declare function resolveSearchLimit(value: number | undefined): number;
+export declare const RELATIVE_DURATION_PATTERN: RegExp;
+export declare const ISO_DATE_PATTERN: RegExp;
+export declare const FIXED_UNIT_MS: Record<string, number>;
+/**
+ * Resolve a search date bound to a GitHub-search-compatible literal. Returns
+ * either a `YYYY-MM-DD` date (relative durations and date-only inputs) or a
+ * full ISO 8601 datetime string (datetime inputs), so the caller can drop it
+ * straight into a qualifier like `created:>=<value>`.
+ */
+export declare function parseSearchDateBound(raw: string, now?: Date): string;
+/**
+ * Build the GitHub-search qualifier (e.g. `created:>=2026-05-09`) for the
+ * provided bounds, or `undefined` if neither bound is set.
+ */
+export declare function buildSearchDateQualifier(field: string, since: string | undefined, until: string | undefined, now?: Date): string | undefined;
+export declare function resolveSearchDateField(command: "issues" | "prs" | "commits" | "repos", requested: "created" | "updated" | undefined): string;
+export declare function composeSearchQuery(parts: ReadonlyArray<string | undefined>): string;
+export declare function buildGhApiSearchArgs(endpoint: "issues" | "code" | "commits" | "repositories", query: string, limit: number, extraHeaders?: ReadonlyArray<string>): string[];
+export declare function repoFromRepositoryUrl(value: string | undefined): string | undefined;
+export declare function apiUserToGhUser(user: GhApiUser | null | undefined): GhUser | undefined;
+export declare function apiLabelsToGhLabels(labels: GhApiLabel[] | undefined): GhLabel[];
+export declare function apiIssueToSearchResult(item: GhApiSearchIssueItem): GhSearchResult;
+export declare function apiCodeToSearchResult(item: GhApiSearchCodeItem): GhSearchCodeResult;
+export declare function apiCommitToSearchResult(item: GhApiSearchCommitItem): GhSearchCommitResult;
+export declare function apiRepoToSearchResult(item: GhApiSearchRepoItem): GhSearchRepoResult;
+/**
+ * Matches search-query qualifiers that already scope to a repository, org, or
+ * user. When present, callers should avoid layering a default `repo:<current>`
+ * on top — the user has already expressed an explicit scope.
+ *
+ * Only the leading `repo:`/`org:`/`user:`/`owner:` token is treated as a
+ * scope marker; arbitrary substrings (e.g. inside quoted text) are ignored.
+ */
+export declare const REPO_SCOPE_QUALIFIER_PATTERN: RegExp;
+/**
+ * Resolve the effective `repo:` scope for a search op. Returns the explicit
+ * `repo` when set, `undefined` when the query already carries a scoping
+ * qualifier, and otherwise the current checkout's `owner/repo` via
+ * `resolveDefaultRepoMemoized`. Resolution failures (no git/gh context, no
+ * configured remote) silently fall back to `undefined` so the search proceeds
+ * across all of GitHub instead of throwing.
+ */
+export declare function resolveSearchRepoScope(cwd: string, repo: string | undefined, query: string | undefined, signal: AbortSignal | undefined): Promise<string | undefined>;
+export declare function formatSearchResults(kind: "issues" | "pull requests", query: string, repo: string | undefined, items: GhSearchResult[]): string;
+export declare function formatSearchCodeResults(query: string, repo: string | undefined, items: GhSearchCodeResult[]): string;
+export declare function formatSearchCommitMessage(message: string | undefined): string | undefined;
+export declare function formatSearchCommitsResults(query: string, repo: string | undefined, items: GhSearchCommitResult[]): string;
+export declare function formatSearchReposResults(query: string, items: GhSearchRepoResult[]): string;
+export declare function executeSearchIssues(session: ToolSession, params: GithubInput, signal: AbortSignal | undefined): Promise<AgentToolResult<GhToolDetails>>;
+export declare function executeSearchPrs(session: ToolSession, params: GithubInput, signal: AbortSignal | undefined): Promise<AgentToolResult<GhToolDetails>>;
+export declare function executeSearchCode(session: ToolSession, params: GithubInput, signal: AbortSignal | undefined): Promise<AgentToolResult<GhToolDetails>>;
+export declare function executeSearchCommits(session: ToolSession, params: GithubInput, signal: AbortSignal | undefined): Promise<AgentToolResult<GhToolDetails>>;
+export declare function executeSearchRepos(session: ToolSession, params: GithubInput, signal: AbortSignal | undefined): Promise<AgentToolResult<GhToolDetails>>;