jeopi-cli 16.2.14 → 16.2.17

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

@@ -0,0 +1,6 @@
+/**
+ * Return the first 12 hex characters of a commit SHA, or undefined when the
+ * input is missing. Shared between GitHub tool argument normalization and the
+ * run-watch renderer.
+ */
+export declare function formatShortSha(value: string | undefined): string | undefined;

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

@@ -0,0 +1,25 @@
+import { type Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { GhToolDetails } from "./gh";
+type GithubToolRenderArgs = {
+    op?: string;
+    run?: string;
+    branch?: string;
+    repo?: string;
+    pr?: string | string[];
+    query?: string;
+};
+export declare const githubToolRenderer: {
+    renderCall(args: GithubToolRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: GhToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: GithubToolRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

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

@@ -0,0 +1,331 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "jeopi-agent-core";
+import type { Settings } from "../config/settings";
+import * as git from "../utils/git";
+import type { ToolSession } from ".";
+import { type CacheStatus } from "./github-cache";
+import type { OutputMeta } from "./output-meta";
+/** Runs `gh --json` for issue data, retrying without optional stateReason on older gh releases. */
+export declare function githubIssueJsonWithStateReasonFallback<T>(cwd: string, args: readonly string[], signal: AbortSignal | undefined, options?: git.GhCommandOptions): Promise<T>;
+declare const githubSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op: "pr_checkout" | "pr_create" | "pr_push" | "repo_view" | "run_watch" | "search_code" | "search_commits" | "search_issues" | "search_prs" | "search_repos";
+    repo?: string | undefined;
+    branch?: string | undefined;
+    pr?: string | string[] | undefined;
+    force?: boolean | undefined;
+    forceWithLease?: boolean | undefined;
+    title?: string | undefined;
+    body?: string | undefined;
+    base?: string | undefined;
+    head?: string | undefined;
+    draft?: boolean | undefined;
+    fill?: boolean | undefined;
+    reviewer?: string[] | undefined;
+    assignee?: string[] | undefined;
+    label?: string[] | undefined;
+    query?: string | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    dateField?: "created" | "updated" | undefined;
+    limit?: number | undefined;
+    run?: string | undefined;
+    tail?: number | undefined;
+}, {}>;
+type GithubInput = typeof githubSchema.infer;
+export interface GhToolDetails {
+    meta?: OutputMeta;
+    artifactId?: string;
+    repo?: string;
+    branch?: string;
+    worktreePath?: string;
+    remote?: string;
+    remoteBranch?: string;
+    headSha?: string;
+    runId?: number;
+    runIds?: number[];
+    status?: string;
+    conclusion?: string;
+    failedJobs?: string[];
+    watch?: GhRunWatchViewDetails;
+    checkouts?: GhPrCheckoutSummary[];
+}
+export interface GhPrCheckoutSummary {
+    prNumber?: number;
+    url?: string;
+    branch: string;
+    worktreePath: string;
+    remote: string;
+    remoteBranch: string;
+    reused: boolean;
+}
+export interface GhRunWatchJobDetails {
+    id: number;
+    name: string;
+    status?: string;
+    conclusion?: string;
+    durationSeconds?: number;
+    url?: string;
+}
+export interface GhRunWatchRunDetails {
+    id: number;
+    workflowName?: string;
+    displayTitle?: string;
+    status?: string;
+    conclusion?: string;
+    branch?: string;
+    headSha?: string;
+    url?: string;
+    jobs: GhRunWatchJobDetails[];
+}
+export interface GhRunWatchFailedLogDetails {
+    runId: number;
+    workflowName?: string;
+    jobName: string;
+    conclusion?: string;
+    tail?: string;
+    available: boolean;
+}
+export interface GhRunWatchViewDetails {
+    mode: "run" | "commit";
+    state: "watching" | "completed";
+    repo: string;
+    branch?: string;
+    headSha?: string;
+    pollCount?: number;
+    note?: string;
+    run?: GhRunWatchRunDetails;
+    runs?: GhRunWatchRunDetails[];
+    failedLogs?: GhRunWatchFailedLogDetails[];
+}
+interface GhUser {
+    login?: string;
+    name?: string | null;
+}
+interface GhLabel {
+    name?: string;
+}
+interface GhComment {
+    author?: GhUser | null;
+    body?: string;
+    createdAt?: string;
+    url?: string;
+    isMinimized?: boolean;
+    minimizedReason?: string | null;
+}
+interface GhRepoTopic {
+    name?: string;
+    topic?: {
+        name?: string;
+    };
+}
+interface GhRepoLanguage {
+    name?: string;
+}
+interface GhRepoBranch {
+    name?: string;
+}
+interface GhRepoViewData {
+    nameWithOwner?: string;
+    description?: string | null;
+    url?: string;
+    sshUrl?: string;
+    defaultBranchRef?: GhRepoBranch | null;
+    homepageUrl?: string | null;
+    forkCount?: number;
+    isArchived?: boolean;
+    isFork?: boolean;
+    primaryLanguage?: GhRepoLanguage | null;
+    repositoryTopics?: GhRepoTopic[];
+    stargazerCount?: number;
+    updatedAt?: string;
+    viewerPermission?: string | null;
+    visibility?: string | null;
+}
+interface GhIssueViewData {
+    author?: GhUser | null;
+    body?: string | null;
+    comments?: GhComment[];
+    createdAt?: string;
+    labels?: GhLabel[];
+    number?: number;
+    state?: string;
+    stateReason?: string | null;
+    title?: string;
+    updatedAt?: string;
+    url?: string;
+}
+interface GhPrFile {
+    path?: string;
+    additions?: number;
+    deletions?: number;
+    changeType?: string;
+}
+interface GhPrViewData extends GhIssueViewData {
+    baseRefName?: string;
+    files?: GhPrFile[];
+    headRefName?: string;
+    headRefOid?: string;
+    headRepository?: GhRepoViewData | null;
+    headRepositoryOwner?: GhUser | null;
+    isCrossRepository?: boolean;
+    isDraft?: boolean;
+    maintainerCanModify?: boolean;
+    mergeStateStatus?: string;
+    reviewComments?: GhPrReviewComment[];
+    reviews?: GhPrReview[];
+    reviewDecision?: string;
+}
+interface GhPrReviewCommit {
+    oid?: string | null;
+}
+interface GhPrReview {
+    author?: GhUser | null;
+    body?: string | null;
+    commit?: GhPrReviewCommit | null;
+    state?: string | null;
+    submittedAt?: string | null;
+}
+interface GhPrReviewComment {
+    author?: GhUser | null;
+    body?: string | null;
+    createdAt?: string;
+    id: number;
+    inReplyToId?: number;
+    line?: number;
+    originalLine?: number;
+    path?: string;
+    side?: string;
+    url?: string;
+}
+/**
+ * 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;
+/**
+ * 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 resolveDefaultRepoMemoized(cwd: string, signal?: AbortSignal): Promise<string>;
+export declare class GithubTool implements AgentTool<typeof githubSchema, GhToolDetails> {
+    private readonly session;
+    readonly name = "github";
+    readonly approval: (args: unknown) => ToolApprovalDecision;
+    readonly summary = "Interact with GitHub issues, pull requests, and repositories";
+    readonly loadMode = "discoverable";
+    readonly label = "GitHub";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        op: "pr_checkout" | "pr_create" | "pr_push" | "repo_view" | "run_watch" | "search_code" | "search_commits" | "search_issues" | "search_prs" | "search_repos";
+        repo?: string | undefined;
+        branch?: string | undefined;
+        pr?: string | string[] | undefined;
+        force?: boolean | undefined;
+        forceWithLease?: boolean | undefined;
+        title?: string | undefined;
+        body?: string | undefined;
+        base?: string | undefined;
+        head?: string | undefined;
+        draft?: boolean | undefined;
+        fill?: boolean | undefined;
+        reviewer?: string[] | undefined;
+        assignee?: string[] | undefined;
+        label?: string[] | undefined;
+        query?: string | undefined;
+        since?: string | undefined;
+        until?: string | undefined;
+        dateField?: "created" | "updated" | undefined;
+        limit?: number | undefined;
+        run?: string | undefined;
+        tail?: number | undefined;
+    }, {}>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): GithubTool | null;
+    execute(_toolCallId: string, params: GithubInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<GhToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<GhToolDetails>>;
+}
+export interface IssueViewLookupOptions {
+    cwd: string;
+    repo?: string;
+    /** Issue number or GitHub issue URL. */
+    issue: string;
+    includeComments?: boolean;
+    signal?: AbortSignal;
+    settings?: Settings;
+    cacheAuthKey?: string | null;
+}
+export interface PrViewLookupOptions {
+    cwd: string;
+    repo: string;
+    number: number;
+    includeComments?: boolean;
+    signal?: AbortSignal;
+    settings?: Settings;
+    cacheAuthKey?: string | null;
+}
+export interface ViewLookupResult<T> {
+    rendered: string;
+    sourceUrl: string | undefined;
+    payload: T;
+    status: CacheStatus;
+    fetchedAt: number;
+}
+/**
+ * Cache-aware issue/view fetcher. Used by both the `github` tool op and the
+ * `issue://` protocol handler so a single shared row services both surfaces.
+ */
+export declare function getOrFetchIssue(options: IssueViewLookupOptions): Promise<ViewLookupResult<GhIssueViewData>>;
+/**
+ * Cache-aware PR view fetcher. Caller must supply a numeric PR number;
+ * branch-name / current-branch lookups bypass the cache entirely upstream
+ * (see `executePrView`).
+ */
+export declare function getOrFetchPr(options: PrViewLookupOptions): Promise<ViewLookupResult<GhPrViewData>>;
+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;
+/**
+ * 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>>;
+export {};

package/dist/types/tools/github-cache.d.ts

@@ -0,0 +1,123 @@
+/**
+ * SQLite-backed cache for rendered `github` issue/PR view output, plus a
+ * generic cache-aware wrapper that the tool ops and the `issue://`/`pr://`
+ * protocol handlers share.
+ *
+ * Storage:
+ *   One process-wide connection opens lazily on first hit and stays open. All
+ *   helpers swallow open/IO failures and degrade to "no cache" so a corrupt or
+ *   unreadable DB never blocks a `gh` call.
+ *
+ *   Soft TTL → return cached row directly.
+ *   Stateful issue/PR rows past soft TTL but within hard TTL → refresh
+ *     synchronously, falling back to the cached row if the live fetch fails.
+ *   Expensive PR diff rows past soft TTL but within hard TTL → return cached
+ *     row AND schedule a background refresh (errors logged, never thrown).
+ *   Past hard TTL → treat as miss and fetch fresh.
+ */
+import { Database } from "bun:sqlite";
+import type { Settings } from "../config/settings";
+export type CacheKind = "issue" | "pr" | "pr-diff";
+export interface CachedView<T = unknown> {
+    authKey: string;
+    repo: string;
+    kind: CacheKind;
+    number: number;
+    includeComments: boolean;
+    fetchedAt: number;
+    payload: T;
+    rendered: string;
+    sourceUrl: string | undefined;
+}
+export declare function openDb(): Database | null;
+/**
+ * Best-effort local fingerprint for the active GitHub CLI credentials.
+ *
+ * Cache hits must not cross account/token boundaries, but doing a `gh api user`
+ * probe before every cached read would defeat the soft-TTL contract that cache
+ * hits avoid a gh round-trip. Instead, key rows by credential material that the
+ * GitHub CLI itself consumes: token environment variables and/or hosts.yml.
+ * The DB stores only a hash, never the token or hosts.yml contents. If no
+ * credential source is visible, callers should pass `null` to bypass caching.
+ */
+export declare function resolveGithubCacheAuthKey(host?: string): string | undefined;
+export declare function getCached<T = unknown>(repo: string, kind: CacheKind, number: number, includeComments: boolean, authKey?: string): CachedView<T> | null;
+export interface PutCachedInput<T = unknown> {
+    authKey?: string;
+    repo: string;
+    kind: CacheKind;
+    number: number;
+    includeComments: boolean;
+    payload: T;
+    rendered: string;
+    sourceUrl?: string;
+    fetchedAt?: number;
+}
+export declare function putCached<T = unknown>(input: PutCachedInput<T>): void;
+/** Drop a specific cache entry. */
+export declare function invalidate(repo: string, kind: CacheKind, number: number, includeComments?: boolean, authKey?: string): void;
+/**
+ * Drop every cached row for a given issue/PR number, regardless of repo,
+ * auth key, include_comments flag, or row kind ({@link CacheKind}). Best-effort:
+ * swallows DB failures the same way {@link invalidate} does.
+ *
+ * Used by the bash-side detector that reacts to `gh issue close` / `gh pr merge`
+ * style mutations. Repo + auth-key narrowing is intentionally skipped because
+ * the bash command often does not name the repo (defaults to cwd's `gh`
+ * config) and resolving the *current* repo from `cwd` for every bash call would
+ * be far more expensive than a write-amplified DELETE.
+ */
+export declare function invalidateAllForNumber(number: number, repo?: string): void;
+/** Drop every cached row. Test helper. */
+export declare function clearAll(): void;
+/**
+ * Drop every cached row for a repo, or all rows when the repo is unknown.
+ * Fallback for current-branch `gh pr merge`/`gh pr close`-style mutations
+ * where the bash command names no PR number or URL, so the target row cannot
+ * be identified. Over-invalidation is deliberate (see module header).
+ */
+export declare function invalidateAllForRepo(repo?: string): void;
+/**
+ * Test/maintenance helper. Closes and forgets the cached connection so the
+ * next access reopens against (possibly) a different DB path.
+ */
+export declare function resetForTests(): void;
+export interface FreshResult<T> {
+    rendered: string;
+    sourceUrl: string | undefined;
+    payload: T;
+}
+export interface CacheLookupOptions<T> {
+    repo: string;
+    kind: CacheKind;
+    number: number;
+    includeComments: boolean;
+    /**
+     * Auth/credential namespace for cache rows. Omit only in storage-layer
+     * tests; pass `null` when production code cannot determine an identity and
+     * must bypass persistent cache reads/writes.
+     */
+    authKey?: string | null;
+    fetchFresh: () => Promise<FreshResult<T>>;
+    settings?: Settings | undefined;
+    now?: number;
+}
+export type CacheStatus = "miss" | "fresh" | "refreshed" | "stale" | "disabled";
+export interface CacheLookupResult<T> {
+    rendered: string;
+    sourceUrl: string | undefined;
+    payload: T;
+    status: CacheStatus;
+    fetchedAt: number;
+}
+export interface CacheTtl {
+    softMs: number;
+    hardMs: number;
+    enabled: boolean;
+}
+export declare function resolveCacheTtl(settings?: Settings): CacheTtl;
+export declare function getOrFetchView<T>(options: CacheLookupOptions<T>): Promise<CacheLookupResult<T>>;
+/**
+ * Human-friendly freshness note for protocol-handler `notes[]` rendering.
+ */
+export declare function formatFreshnessNote(status: CacheStatus, fetchedAtMs: number, now?: number): string;

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

@@ -0,0 +1,94 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
+import type { ToolExample } from "jeopi-ai";
+import type { Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { type TruncationResult } from "../session/streaming-output";
+import type { ToolSession } from ".";
+import { type OutputMeta } from "./output-meta";
+declare const findSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    paths: string[];
+    hidden?: boolean | undefined;
+    gitignore?: boolean | undefined;
+    limit?: number | undefined;
+}, {}>;
+export type GlobToolInput = typeof findSchema.infer;
+export interface GlobToolDetails {
+    truncation?: TruncationResult;
+    resultLimitReached?: number;
+    meta?: OutputMeta;
+    scopePath?: string;
+    fileCount?: number;
+    files?: string[];
+    truncated?: boolean;
+    error?: string;
+    /** Working directory at search time. Used by the renderer to resolve relative
+     * file paths to absolute paths for OSC 8 hyperlinks. */
+    cwd?: string;
+    /** User-supplied paths whose base directory was missing on disk. The tool
+     * skipped these and continued with the surviving entries; surfaced as a
+     * non-fatal warning in the renderer and in the model-facing text. */
+    missingPaths?: string[];
+}
+/**
+ * Pluggable operations for the find tool.
+ * Override these to delegate file search to remote systems (e.g., SSH).
+ */
+export interface GlobOperations {
+    /** Check if path exists */
+    exists: (absolutePath: string) => Promise<boolean> | boolean;
+    /** Optional stat for distinguishing files vs directories. */
+    stat?: (absolutePath: string) => Promise<{
+        isFile(): boolean;
+        isDirectory(): boolean;
+    }> | {
+        isFile(): boolean;
+        isDirectory(): boolean;
+    };
+    /** Find files matching glob pattern. Returns relative paths. */
+    glob: (pattern: string, cwd: string, options: {
+        ignore: string[];
+        limit: number;
+    }) => Promise<string[]> | string[];
+}
+export interface GlobToolOptions {
+    /** Custom operations for find. Default: local filesystem + rg */
+    operations?: GlobOperations;
+}
+export declare class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "glob";
+    readonly approval: "read";
+    readonly loadMode = "essential";
+    readonly label = "Glob";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        paths: string[];
+        hidden?: boolean | undefined;
+        gitignore?: boolean | undefined;
+        limit?: number | undefined;
+    }, {}>;
+    readonly examples: readonly ToolExample<typeof findSchema.infer>[];
+    readonly strict = true;
+    constructor(session: ToolSession, options?: GlobToolOptions);
+    execute(_toolCallId: string, params: typeof findSchema.infer, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<GlobToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<GlobToolDetails>>;
+}
+interface GlobRenderArgs {
+    paths?: string | string[];
+    limit?: number;
+}
+export declare const globToolRenderer: {
+    inline: boolean;
+    renderCall(args: GlobRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: GlobToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: GlobRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

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

@@ -0,0 +1,98 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolTier } from "jeopi-agent-core";
+import type { Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { type TruncationResult } from "../session/streaming-output";
+import type { ToolSession } from ".";
+import type { OutputMeta } from "./output-meta";
+declare const searchSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    pattern: string;
+    paths?: string | string[] | undefined;
+    case?: boolean | undefined;
+    gitignore?: boolean | undefined;
+    skip?: number | null | undefined;
+}, {}>;
+export type GrepToolInput = typeof searchSchema.infer;
+export declare function toPathList(input: string | string[] | undefined): string[];
+/** Maximum number of distinct files surfaced in a single response. The
+ * agent paginates further pages via `skip`. */
+export declare const DEFAULT_FILE_LIMIT = 20;
+/** Per-file match cap for multi-file searches — keeps a single hot file
+ * from crowding out diverse hits. Applied in JS after grep returns. */
+export declare const MULTI_FILE_PER_FILE_MATCHES = 20;
+/** Per-file match cap for single-file searches — there's no diversity
+ * concern when the scope is one file. */
+export declare const SINGLE_FILE_MATCHES = 200;
+export interface GrepToolDetails {
+    truncation?: TruncationResult;
+    fileLimitReached?: number;
+    perFileLimitReached?: number;
+    linesTruncated?: boolean;
+    meta?: OutputMeta;
+    scopePath?: string;
+    matchCount?: number;
+    fileCount?: number;
+    files?: string[];
+    fileMatches?: Array<{
+        path: string;
+        count: number;
+    }>;
+    truncated?: boolean;
+    error?: string;
+    /** Pre-formatted text for the user-visible TUI render. Mirrors the model-facing
+     * `result.text` lines but uses a `│` gutter and `*` to mark match lines (vs space for
+     * context). The TUI uses this directly so it never parses model-facing hashline anchors. */
+    displayContent?: string;
+    /** Absolute base directory used during search. Used by the renderer to resolve
+     * display-relative paths to absolute paths for OSC 8 hyperlinks. */
+    searchPath?: string;
+    /** Session cwd at search time. The renderer resolves the display-relative
+     * (cwd-relative) header/match paths against this for OSC 8 hyperlinks;
+     * `searchPath` is the scope label target, not the display-path base. */
+    cwd?: string;
+    /** User-supplied paths whose base directory was missing on disk. The tool
+     * skipped these and continued with the surviving entries; surfaced as a
+     * non-fatal warning in the renderer and in the model-facing text. */
+    missingPaths?: string[];
+}
+type SearchParams = typeof searchSchema.infer;
+export declare class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails> {
+    private readonly session;
+    readonly name = "grep";
+    readonly approval: (args: unknown) => ToolTier;
+    readonly label = "Grep";
+    readonly loadMode = "discoverable";
+    readonly summary = "Grep file contents using ripgrep (fast regex search)";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        pattern: string;
+        paths?: string | string[] | undefined;
+        case?: boolean | undefined;
+        gitignore?: boolean | undefined;
+        skip?: number | null | undefined;
+    }, {}>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: SearchParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<GrepToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<GrepToolDetails>>;
+}
+interface GrepRenderArgs {
+    pattern: string;
+    paths?: string | string[];
+    case?: boolean;
+    gitignore?: boolean;
+    skip?: number;
+}
+export declare const grepToolRenderer: {
+    inline: boolean;
+    renderCall(args: GrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: GrepToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: GrepRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};