@sayknow-cli/coding-agent 0.3.6 → 0.3.8

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

@@ -0,0 +1,91 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from "./index";
+/** Maximum scheduled tasks per owner. Mirrors upstream Claude Code's 50-task cap. */
+export declare const MAX_CRON_TASKS_PER_OWNER = 50;
+/** Recurring tasks auto-expire 7 days after creation (mirrors upstream). */
+export declare const CRON_RECURRING_MAX_AGE_MS: number;
+declare const cronSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        list: "list";
+    }>;
+    cron_expression: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    recurring: z.ZodOptional<z.ZodBoolean>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CronParams = z.infer<typeof cronSchema>;
+export interface CronJobSnapshot {
+    id: string;
+    cron_expression: string;
+    prompt: string;
+    recurring: boolean;
+    createdAt: number;
+    expiresAt?: number;
+    nextFireAt?: number;
+    humanSchedule: string;
+    ownerId?: string;
+}
+export interface CronListJobDetails {
+    id: string;
+    cron: string;
+    recurring: boolean;
+    prompt: string;
+    humanSchedule: string;
+}
+export interface CronToolDetails {
+    op: "create" | "list" | "delete";
+    id?: string;
+    cron_expression?: string;
+    recurring?: boolean;
+    nextFireAt?: number;
+    jobs?: CronListJobDetails[];
+    deleted?: boolean;
+}
+/** Clear every schedule for an owner. Exported for tests + lifecycle teardown. */
+export declare function clearOwnerSchedules(ownerId: string | undefined): void;
+/** Reset every owner's schedule store. Test-only. */
+export declare function resetCronRegistryForTests(): void;
+/** Subscribe to cron schedule-set changes. Returns an unsubscribe function. */
+export declare function onCronChange(cb: () => void): () => void;
+/** Snapshot the scheduled cron jobs for an owner (or all owners when omitted). */
+export declare function listCronSnapshots(ownerId?: string): CronJobSnapshot[];
+/** Delete a scheduled cron job by owner-scoped id. Returns true when removed. */
+export declare function deleteCronJobById(ownerId: string | undefined, id: string): boolean;
+export declare function validateCronExpression(expression: string): void;
+export declare function findNextCronMatchMs(expression: string, afterMs: number, deadlineMs?: number): number | undefined;
+export declare function calculateCronFireTimeMs(params: {
+    id: string;
+    cronExpression: string;
+    baseMatchMs: number;
+    recurring: boolean;
+    nowMs: number;
+    expiresAt?: number;
+}): number;
+export declare class CronTool implements AgentTool<typeof cronSchema, CronToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "cron";
+    readonly label = "Cron";
+    readonly summary = "Schedule, list, and cancel cron-style prompts (op: create | list | delete)";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        op: z.ZodEnum<{
+            create: "create";
+            delete: "delete";
+            list: "list";
+        }>;
+        cron_expression: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+        recurring: z.ZodOptional<z.ZodBoolean>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): CronTool | null;
+    execute(_toolCallId: string, params: CronParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronToolDetails>>;
+}
+export {};

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

@@ -0,0 +1,209 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, RenderResultOptions } from "@sayknow-cli/agent-core";
+import { type Component } from "@sayknow-cli/tui";
+import * as z from "zod/v4";
+import { type DapBreakpointRecord, type DapContinueOutcome, type DapDataBreakpointInfoResponse, type DapDataBreakpointRecord, type DapDisassembledInstruction, type DapEvaluateResponse, type DapFunctionBreakpointRecord, type DapInstructionBreakpointRecord, type DapModule, type DapScope, type DapSessionSummary, type DapSource, type DapStackFrame, type DapThread, type DapVariable } from "../dap";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+import type { OutputMeta } from "./output-meta";
+declare const debugSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        attach: "attach";
+        continue: "continue";
+        custom_request: "custom_request";
+        data_breakpoint_info: "data_breakpoint_info";
+        disassemble: "disassemble";
+        evaluate: "evaluate";
+        launch: "launch";
+        loaded_sources: "loaded_sources";
+        modules: "modules";
+        output: "output";
+        pause: "pause";
+        read_memory: "read_memory";
+        remove_breakpoint: "remove_breakpoint";
+        remove_data_breakpoint: "remove_data_breakpoint";
+        remove_instruction_breakpoint: "remove_instruction_breakpoint";
+        scopes: "scopes";
+        sessions: "sessions";
+        set_breakpoint: "set_breakpoint";
+        set_data_breakpoint: "set_data_breakpoint";
+        set_instruction_breakpoint: "set_instruction_breakpoint";
+        stack_trace: "stack_trace";
+        step_in: "step_in";
+        step_out: "step_out";
+        step_over: "step_over";
+        terminate: "terminate";
+        threads: "threads";
+        variables: "variables";
+        write_memory: "write_memory";
+    }>;
+    program: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    adapter: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    function: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    condition: z.ZodOptional<z.ZodString>;
+    hit_condition: z.ZodOptional<z.ZodString>;
+    expression: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+    frame_id: z.ZodOptional<z.ZodNumber>;
+    scope_id: z.ZodOptional<z.ZodNumber>;
+    variable_ref: z.ZodOptional<z.ZodNumber>;
+    pid: z.ZodOptional<z.ZodNumber>;
+    port: z.ZodOptional<z.ZodNumber>;
+    host: z.ZodOptional<z.ZodString>;
+    levels: z.ZodOptional<z.ZodNumber>;
+    memory_reference: z.ZodOptional<z.ZodString>;
+    instruction_reference: z.ZodOptional<z.ZodString>;
+    instruction_count: z.ZodOptional<z.ZodNumber>;
+    instruction_offset: z.ZodOptional<z.ZodNumber>;
+    count: z.ZodOptional<z.ZodNumber>;
+    data: z.ZodOptional<z.ZodString>;
+    data_id: z.ZodOptional<z.ZodString>;
+    access_type: z.ZodOptional<z.ZodEnum<{
+        read: "read";
+        readWrite: "readWrite";
+        write: "write";
+    }>>;
+    command: z.ZodOptional<z.ZodString>;
+    arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    resolve_symbols: z.ZodOptional<z.ZodBoolean>;
+    allow_partial: z.ZodOptional<z.ZodBoolean>;
+    start_module: z.ZodOptional<z.ZodNumber>;
+    module_count: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DebugParams = z.infer<typeof debugSchema>;
+export type DebugAction = DebugParams["action"];
+interface DebugToolDetails {
+    action: DebugAction;
+    success: boolean;
+    snapshot?: DapSessionSummary;
+    sessions?: DapSessionSummary[];
+    stackFrames?: DapStackFrame[];
+    threads?: DapThread[];
+    scopes?: DapScope[];
+    variables?: DapVariable[];
+    sources?: DapSource[];
+    modules?: DapModule[];
+    evaluation?: DapEvaluateResponse;
+    breakpoints?: DapBreakpointRecord[];
+    functionBreakpoints?: DapFunctionBreakpointRecord[];
+    instructionBreakpoints?: DapInstructionBreakpointRecord[];
+    dataBreakpoints?: DapDataBreakpointRecord[];
+    dataBreakpointInfo?: DapDataBreakpointInfoResponse;
+    disassembly?: DapDisassembledInstruction[];
+    memoryAddress?: string;
+    memoryData?: string;
+    unreadableBytes?: number;
+    bytesWritten?: number;
+    customBody?: unknown;
+    output?: string;
+    adapter?: string;
+    state?: DapContinueOutcome["state"];
+    timedOut?: boolean;
+    meta?: OutputMeta;
+}
+interface DebugRenderArgs extends Partial<DebugParams> {
+}
+export declare const debugToolRenderer: {
+    renderCall(args: DebugRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: DebugToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: DebugRenderArgs): Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+};
+export declare class DebugTool implements AgentTool<typeof debugSchema, DebugToolDetails> {
+    private readonly session;
+    readonly name = "debug";
+    readonly label = "Debug";
+    readonly summary = "Debug a running process with DAP (debugger adapter protocol)";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        action: z.ZodEnum<{
+            attach: "attach";
+            continue: "continue";
+            custom_request: "custom_request";
+            data_breakpoint_info: "data_breakpoint_info";
+            disassemble: "disassemble";
+            evaluate: "evaluate";
+            launch: "launch";
+            loaded_sources: "loaded_sources";
+            modules: "modules";
+            output: "output";
+            pause: "pause";
+            read_memory: "read_memory";
+            remove_breakpoint: "remove_breakpoint";
+            remove_data_breakpoint: "remove_data_breakpoint";
+            remove_instruction_breakpoint: "remove_instruction_breakpoint";
+            scopes: "scopes";
+            sessions: "sessions";
+            set_breakpoint: "set_breakpoint";
+            set_data_breakpoint: "set_data_breakpoint";
+            set_instruction_breakpoint: "set_instruction_breakpoint";
+            stack_trace: "stack_trace";
+            step_in: "step_in";
+            step_out: "step_out";
+            step_over: "step_over";
+            terminate: "terminate";
+            threads: "threads";
+            variables: "variables";
+            write_memory: "write_memory";
+        }>;
+        program: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        adapter: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        function: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        condition: z.ZodOptional<z.ZodString>;
+        hit_condition: z.ZodOptional<z.ZodString>;
+        expression: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodString>;
+        frame_id: z.ZodOptional<z.ZodNumber>;
+        scope_id: z.ZodOptional<z.ZodNumber>;
+        variable_ref: z.ZodOptional<z.ZodNumber>;
+        pid: z.ZodOptional<z.ZodNumber>;
+        port: z.ZodOptional<z.ZodNumber>;
+        host: z.ZodOptional<z.ZodString>;
+        levels: z.ZodOptional<z.ZodNumber>;
+        memory_reference: z.ZodOptional<z.ZodString>;
+        instruction_reference: z.ZodOptional<z.ZodString>;
+        instruction_count: z.ZodOptional<z.ZodNumber>;
+        instruction_offset: z.ZodOptional<z.ZodNumber>;
+        count: z.ZodOptional<z.ZodNumber>;
+        data: z.ZodOptional<z.ZodString>;
+        data_id: z.ZodOptional<z.ZodString>;
+        access_type: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            readWrite: "readWrite";
+            write: "write";
+        }>>;
+        command: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        resolve_symbols: z.ZodOptional<z.ZodBoolean>;
+        allow_partial: z.ZodOptional<z.ZodBoolean>;
+        start_module: z.ZodOptional<z.ZodNumber>;
+        module_count: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly concurrency = "exclusive";
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): DebugTool | null;
+    execute(_toolCallId: string, params: DebugParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<DebugToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<DebugToolDetails>>;
+}
+export {};

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

@@ -0,0 +1,108 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import type { Component } from "@sayknow-cli/tui";
+import * as z from "zod/v4";
+import type { EvalToolDetails } from "../eval/types";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type Theme } from "../modes/theme/theme";
+import { type ToolSession } from ".";
+export declare const EVAL_DEFAULT_PREVIEW_LINES = 10;
+/**
+ * Per-cell input. Each cell runs in order; state persists within a language
+ * across cells and across tool calls.
+ */
+declare const evalCellSchema: z.ZodObject<{
+    language: z.ZodEnum<{
+        js: "js";
+        py: "py";
+    }>;
+    code: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    reset: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type EvalCellInput = z.infer<typeof evalCellSchema>;
+export declare const evalSchema: z.ZodObject<{
+    cells: z.ZodArray<z.ZodObject<{
+        language: z.ZodEnum<{
+            js: "js";
+            py: "py";
+        }>;
+        code: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        reset: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type EvalToolParams = z.infer<typeof evalSchema>;
+export type EvalToolResult = {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    details: EvalToolDetails | undefined;
+};
+export type EvalProxyExecutor = (params: EvalToolParams, signal?: AbortSignal) => Promise<EvalToolResult>;
+export interface EvalToolDescriptionOptions {
+    py?: boolean;
+    js?: boolean;
+}
+export declare function getEvalToolDescription(options?: EvalToolDescriptionOptions): string;
+export interface EvalToolOptions {
+    proxyExecutor?: EvalProxyExecutor;
+}
+export declare class EvalTool implements AgentTool<typeof evalSchema> {
+    #private;
+    private readonly session;
+    readonly name = "eval";
+    readonly summary = "Execute Python or JavaScript code in an in-process eval backend";
+    readonly loadMode = "discoverable";
+    readonly label = "Eval";
+    get description(): string;
+    readonly parameters: z.ZodObject<{
+        cells: z.ZodArray<z.ZodObject<{
+            language: z.ZodEnum<{
+                js: "js";
+                py: "py";
+            }>;
+            code: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+            reset: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly concurrency = "exclusive";
+    readonly strict = true;
+    readonly intent: (args: Partial<z.infer<typeof evalSchema>>) => string | undefined;
+    constructor(session: ToolSession | null, options?: EvalToolOptions);
+    execute(_toolCallId: string, params: z.infer<typeof evalSchema>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback, _ctx?: AgentToolContext): Promise<AgentToolResult<EvalToolDetails | undefined>>;
+}
+interface EvalRenderCellArg {
+    language?: string;
+    code?: string;
+    title?: string;
+}
+interface EvalRenderArgs {
+    cells?: EvalRenderCellArg[];
+    __partialJson?: string;
+}
+interface EvalRenderContext {
+    output?: string;
+    expanded?: boolean;
+    previewLines?: number;
+    timeout?: number;
+}
+export declare const evalToolRenderer: {
+    renderCall(args: EvalRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: EvalToolDetails;
+    }, options: RenderResultOptions & {
+        renderContext?: EvalRenderContext;
+    }, uiTheme: Theme, _args?: EvalRenderArgs): Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+};
+export {};

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

@@ -0,0 +1,84 @@
+import type { AgentToolResult } from "@sayknow-cli/agent-core";
+import { type Component } from "@sayknow-cli/tui";
+import type { Settings } from "../config/settings";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type Theme } from "../modes/theme/theme";
+import type { ToolSession } from "../sdk";
+import type { RenderResult } from "../web/scrapers/types";
+import { type OutputMeta } from "./output-meta";
+export declare function isReadableUrlPath(value: string): boolean;
+export interface ParsedReadUrlTarget {
+    path: string;
+    raw: boolean;
+    offset?: number;
+    limit?: number;
+}
+export declare function parseReadUrlTarget(readPath: string): ParsedReadUrlTarget | null;
+interface FetchImagePayload {
+    data: string;
+    mimeType: string;
+}
+type FetchRenderResult = RenderResult & {
+    image?: FetchImagePayload;
+};
+/**
+ * Opt-in insane-search fallback for blocked / degraded public URL reads.
+ *
+ * Returns a finalized `method: "insane"` result on success, or null (so the
+ * caller continues with its normal degraded behavior). Fail-closed: no note,
+ * guard DNS, dependency probe, or subprocess when raw mode or the opt-in
+ * setting is off. The public-URL guard runs BEFORE any probe/spawn.
+ */
+export declare function tryInsaneFallback(args: {
+    url: string;
+    finalUrl: string;
+    timeout: number;
+    raw: boolean;
+    settings: Settings;
+    signal: AbortSignal | undefined;
+    fetchedAt: string;
+    notes: string[];
+}): Promise<FetchRenderResult | null>;
+export interface ReadUrlToolDetails {
+    kind: "url";
+    url: string;
+    finalUrl: string;
+    contentType: string;
+    method: string;
+    truncated: boolean;
+    notes: string[];
+    meta?: OutputMeta;
+}
+interface ReadUrlCacheEntry {
+    artifactId?: string;
+    details: ReadUrlToolDetails;
+    image?: FetchImagePayload;
+    output: string;
+}
+export declare function loadReadUrlCacheEntry(session: ToolSession, params: {
+    path: string;
+    raw?: boolean;
+}, signal?: AbortSignal, options?: {
+    ensureArtifact?: boolean;
+    preferCached?: boolean;
+}): Promise<ReadUrlCacheEntry>;
+export declare function executeReadUrl(session: ToolSession, params: {
+    path: string;
+    raw?: boolean;
+}, signal?: AbortSignal): Promise<AgentToolResult<ReadUrlToolDetails>>;
+/** Render URL read call (URL preview) */
+export declare function renderReadUrlCall(args: {
+    path?: string;
+    url?: string;
+    raw?: boolean;
+}, _options: RenderResultOptions, uiTheme?: Theme): Component;
+/** Render URL read result with tree-based layout */
+export declare function renderReadUrlResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: ReadUrlToolDetails;
+    isError?: boolean;
+}, options: RenderResultOptions, uiTheme?: Theme): Component;
+export {};

package/dist/types/tools/file-recorder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Creates a deduplicating recorder for relative file paths.
+ * Preserves insertion order in `list`; subsequent duplicates are ignored.
+ */
+export declare function createFileRecorder(): {
+    record: (relativePath: string) => void;
+    list: string[];
+};
+/**
+ * Strip native virtual-root prefixes and format file paths relative to cwd when
+ * they are inside cwd. Paths outside cwd remain absolute.
+ */
+export declare function formatResultPath(filePath: string, isDirectory: boolean, basePath: string, cwd: string): string;

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

@@ -0,0 +1,95 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
+import type { Component } from "@sayknow-cli/tui";
+import * as z from "zod/v4";
+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: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString>;
+    hidden: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    gitignore: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, z.core.$strict>;
+export type FindToolInput = z.infer<typeof findSchema>;
+export interface FindToolDetails {
+    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 FindOperations {
+    /** 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 FindToolOptions {
+    /** Custom operations for find. Default: local filesystem + rg */
+    operations?: FindOperations;
+}
+export declare class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "find";
+    readonly summary = "Find files and directories matching a glob pattern";
+    readonly loadMode = "discoverable";
+    readonly label = "Find";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        paths: z.ZodArray<z.ZodString>;
+        hidden: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        gitignore: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strict>;
+    readonly strict = true;
+    constructor(session: ToolSession, options?: FindToolOptions);
+    execute(_toolCallId: string, params: z.infer<typeof findSchema>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<FindToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<FindToolDetails>>;
+}
+interface FindRenderArgs {
+    paths?: string[];
+    limit?: number;
+}
+export declare const findToolRenderer: {
+    inline: boolean;
+    renderCall(args: FindRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: FindToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: FindRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/fs-cache-invalidation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Invalidate shared filesystem scan caches after a content write/update.
+ */
+export declare function invalidateFsScanAfterWrite(path: string): void;
+/**
+ * Invalidate shared filesystem scan caches after deleting a file.
+ */
+export declare function invalidateFsScanAfterDelete(path: string): void;
+/**
+ * Invalidate shared filesystem scan caches after a rename/move.
+ *
+ * Some watchers care about the disappearance at the old path; others about the
+ * appearance at the new one. Bust both to keep callers honest.
+ */
+export declare function invalidateFsScanAfterRename(oldPath: string, newPath: string): void;

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 "@sayknow-cli/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 {};