@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.2

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

@@ -0,0 +1,19 @@
+import type { AgentToolContext, ToolCallContext } from "@oh-my-pi/pi-agent-core";
+import type { CustomToolContext } from "../extensibility/custom-tools/types";
+import type { ExtensionUIContext } from "../extensibility/extensions/types";
+declare module "@oh-my-pi/pi-agent-core" {
+    interface AgentToolContext extends CustomToolContext {
+        ui?: ExtensionUIContext;
+        hasUI?: boolean;
+        toolNames?: string[];
+        toolCall?: ToolCallContext;
+    }
+}
+export declare class ToolContextStore {
+    #private;
+    private readonly getBaseContext;
+    constructor(getBaseContext: () => CustomToolContext);
+    getContext(toolCall?: ToolCallContext): AgentToolContext;
+    setUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
+    setToolNames(names: string[]): void;
+}

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

@@ -0,0 +1,209 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, RenderResultOptions } from "@oh-my-pi/pi-agent-core";
+import { type Component } from "@oh-my-pi/pi-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,74 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-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;
+export declare const evalSchema: z.ZodObject<{
+    input: z.ZodString;
+}, 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<{
+        input: z.ZodString;
+    }, z.core.$strip>;
+    readonly concurrency = "exclusive";
+    readonly strict = true;
+    readonly intent: (args: Partial<z.infer<typeof evalSchema>>) => string | undefined;
+    get customFormat(): {
+        syntax: "lark";
+        definition: string;
+    };
+    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 EvalRenderArgs {
+    input?: string;
+    __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,61 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { type Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type Theme } from "../modes/theme/theme";
+import type { ToolSession } from "../sdk";
+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;
+}
+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,88 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-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>>;
+    limit: 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;
+    /** 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>>;
+        limit: 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 "@oh-my-pi/pi-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 {};