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

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

@@ -0,0 +1,244 @@
+import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { ToolChoice } from "@oh-my-pi/pi-ai";
+import type { PromptTemplate } from "../config/prompt-templates";
+import type { Settings } from "../config/settings";
+import type { Skill } from "../extensibility/skills";
+import type { GoalModeState, GoalRuntime } from "../goals";
+import type { HindsightSessionState } from "../hindsight/state";
+import type { PlanModeState } from "../plan-mode/state";
+import { type AgentRegistry } from "../registry/agent-registry";
+import type { ArtifactManager } from "../session/artifacts";
+import type { ClientBridge } from "../session/client-bridge";
+import type { CustomMessage } from "../session/messages";
+import type { ToolChoiceQueue } from "../session/tool-choice-queue";
+import type { AgentOutputManager } from "../task/output-manager";
+import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
+import type { EventBus } from "../utils/event-bus";
+import type { WorkspaceTree } from "../workspace-tree";
+import { type CheckpointState } from "./checkpoint";
+import { type TodoPhase } from "./todo-write";
+export * from "../edit";
+export * from "../exa";
+export type * from "../exa/types";
+export * from "../goals";
+export * from "../lsp";
+export * from "../session/streaming-output";
+export * from "../task";
+export * from "../web/search";
+export * from "./ask";
+export * from "./ast-edit";
+export * from "./ast-grep";
+export * from "./bash";
+export * from "./browser";
+export * from "./calculator";
+export * from "./checkpoint";
+export * from "./debug";
+export * from "./eval";
+export * from "./find";
+export * from "./gh";
+export * from "./hindsight-recall";
+export * from "./hindsight-reflect";
+export * from "./hindsight-retain";
+export * from "./image-gen";
+export * from "./inspect-image";
+export * from "./irc";
+export * from "./job";
+export * from "./read";
+export * from "./recipe";
+export * from "./render-mermaid";
+export * from "./report-tool-issue";
+export * from "./resolve";
+export * from "./review";
+export * from "./search";
+export * from "./search-tool-bm25";
+export * from "./ssh";
+export * from "./todo-write";
+export * from "./vim";
+export * from "./write";
+export * from "./yield";
+/** Tool type (AgentTool from pi-ai) */
+export type Tool = AgentTool<any, any, any>;
+export type ContextFileEntry = {
+    path: string;
+    content: string;
+    depth?: number;
+};
+export type { DiscoverableMCPTool } from "../mcp/discoverable-tool-metadata";
+export type { DiscoverableTool, DiscoverableToolSearchIndex, DiscoverableToolSearchResult, DiscoverableToolSource, } from "../tool-discovery/tool-index";
+/** Session context for tool factories */
+export interface ToolSession {
+    /** Current working directory */
+    cwd: string;
+    /** Whether UI is available */
+    hasUI: boolean;
+    /** Skip Python kernel availability check and warmup */
+    skipPythonPreflight?: boolean;
+    /** Pre-loaded context files (AGENTS.md, etc) */
+    contextFiles?: ContextFileEntry[];
+    /** Pre-loaded workspace tree (forwarded to subagents to skip re-scanning) */
+    workspaceTree?: WorkspaceTree;
+    /** Pre-loaded skills */
+    skills?: Skill[];
+    /** Pre-loaded prompt templates */
+    promptTemplates?: PromptTemplate[];
+    /** Whether LSP integrations are enabled */
+    enableLsp?: boolean;
+    /** Whether an edit-capable tool is available in this session (controls hashline output) */
+    hasEditTool?: boolean;
+    /** Event bus for tool/extension communication */
+    eventBus?: EventBus;
+    /** Output schema for structured completion (subagents) */
+    outputSchema?: unknown;
+    /** Whether to include the yield tool by default */
+    requireYieldTool?: boolean;
+    /** Task recursion depth (0 = top-level, 1 = first child, etc.) */
+    taskDepth?: number;
+    /** Get session file */
+    getSessionFile: () => string | null;
+    /** Get eval kernel owner ID for session-scoped retained-kernel cleanup. */
+    getEvalKernelOwnerId?: () => string | null;
+    /** Reject new eval (python or js) work once session disposal has started. */
+    assertEvalExecutionAllowed?: () => void;
+    /** Track tool-owned eval work so session disposal can await/abort it like direct session eval runs. */
+    trackEvalExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
+    /** Get session ID */
+    getSessionId?: () => string | null;
+    /** Get Hindsight runtime state for this agent session. */
+    getHindsightSessionState?: () => HindsightSessionState | undefined;
+    /** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
+    getAgentId?: () => string | null;
+    /** Look up a registered tool by name (used by the eval js backend's tool bridge). */
+    getToolByName?: (name: string) => AgentTool | undefined;
+    /** Agent registry for IRC routing across live sessions. */
+    agentRegistry?: AgentRegistry;
+    /** Get artifacts directory for artifact:// URLs */
+    getArtifactsDir?: () => string | null;
+    /** Get the ArtifactManager backing this session (shared across parent + subagents). */
+    getArtifactManager?: () => ArtifactManager | null;
+    /** Allocate a new artifact path and ID for session-scoped truncated output. */
+    allocateOutputArtifact?: (toolType: string) => Promise<{
+        id?: string;
+        path?: string;
+    }>;
+    /** Get session spawns */
+    getSessionSpawns: () => string | null;
+    /** Get resolved model string if explicitly set for this session */
+    getModelString?: () => string | undefined;
+    /** Get the current session model string, regardless of how it was chosen */
+    getActiveModelString?: () => string | undefined;
+    /** Auth storage for passing to subagents (avoids re-discovery) */
+    authStorage?: import("../session/auth-storage").AuthStorage;
+    /** Model registry for passing to subagents (avoids re-discovery) */
+    modelRegistry?: import("../config/model-registry").ModelRegistry;
+    /** Agent output manager for unique agent:// IDs across task invocations */
+    agentOutputManager?: AgentOutputManager;
+    /** Settings instance for passing to subagents */
+    settings: Settings;
+    /** Plan mode state (if active) */
+    getPlanModeState?: () => PlanModeState | undefined;
+    /** Goal mode state (if active or paused) */
+    getGoalModeState?: () => GoalModeState | undefined;
+    /** Goal runtime for the active agent session. */
+    getGoalRuntime?: () => GoalRuntime | undefined;
+    /** Bridge to the connected client (e.g. ACP editor host). Tools should route fs/terminal/permission requests through this when available. */
+    getClientBridge?: () => ClientBridge | undefined;
+    /** Get compact conversation context for subagents (excludes tool results, system prompts) */
+    getCompactContext?: () => string;
+    /** Get cached todo phases for this session. */
+    getTodoPhases?: () => TodoPhase[];
+    /** Replace cached todo phases for this session. */
+    setTodoPhases?: (phases: TodoPhase[]) => void;
+    /** Whether MCP tool discovery is active for this session. */
+    isMCPDiscoveryEnabled?: () => boolean;
+    /** Get hidden-but-discoverable MCP tools for search_tool_bm25 prompts and fallbacks.
+     * @deprecated Use getDiscoverableTools with source filter instead. */
+    getDiscoverableMCPTools?: () => import("../mcp/discoverable-tool-metadata").DiscoverableMCPTool[];
+    /** Get the cached discoverable MCP search index for search_tool_bm25 execution.
+     * @deprecated Use getDiscoverableToolSearchIndex instead. */
+    getDiscoverableMCPSearchIndex?: () => import("../tool-discovery/tool-index").DiscoverableMCPSearchIndex;
+    /** Get MCP tools activated by prior search_tool_bm25 calls. */
+    getSelectedMCPToolNames?: () => string[];
+    /** Merge MCP tool selections into the active session tool set. */
+    activateDiscoveredMCPTools?: (toolNames: string[]) => Promise<string[]>;
+    /** Whether any form of tool discovery is active (tools.discoveryMode !== "off" or mcp.discoveryMode). */
+    isToolDiscoveryEnabled?: () => boolean;
+    /** Get all hidden-but-discoverable tools for search_tool_bm25 prompts. */
+    getDiscoverableTools?: (filter?: {
+        source?: import("../tool-discovery/tool-index").DiscoverableToolSource;
+    }) => DiscoverableTool[];
+    /** Get the cached generic discoverable search index. */
+    getDiscoverableToolSearchIndex?: () => DiscoverableToolSearchIndex;
+    /** Get tool names activated by prior search_tool_bm25 calls (all sources). */
+    getSelectedDiscoveredToolNames?: () => string[];
+    /** Merge tool selections into the active session tool set. */
+    activateDiscoveredTools?: (toolNames: string[]) => Promise<string[]>;
+    /** The tool-choice queue used to force forthcoming tool invocations and carry invocation handlers. */
+    getToolChoiceQueue?(): ToolChoiceQueue;
+    /** Build a model-provider-specific ToolChoice that targets the named tool, or undefined if unsupported. */
+    buildToolChoice?(toolName: string): ToolChoice | undefined;
+    /** Steer a hidden custom message into the conversation (e.g. a preview reminder). */
+    steer?(message: {
+        customType: string;
+        content: string;
+        details?: unknown;
+    }): void;
+    /** Peek the currently in-flight tool-choice queue directive's invocation handler. Used by the `resolve` tool to dispatch to the pending action. */
+    peekQueueInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+    /** Peek the long-lived "standing" resolve handler registered by a mode (e.g. plan mode).
+     *  Consulted by the `resolve` tool as a fallback when no queue invoker is in flight,
+     *  letting modes accept `resolve` invocations without forcing the tool choice every turn. */
+    peekStandingResolveHandler?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+    /** Register or clear the standing resolve handler. Passing `null` clears it. */
+    setStandingResolveHandler?(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void;
+    /** Get active checkpoint state if any. */
+    getCheckpointState?: () => CheckpointState | undefined;
+    /** Set or clear active checkpoint state. */
+    setCheckpointState?: (state: CheckpointState | null) => void;
+    /** Per-session cache of file contents as last shown to the model by
+     *  `read`/`search`. Used by hashline anchor-stale recovery to reconstruct
+     *  the version the model authored anchors against when the file changed
+     *  out-of-band. Lazily initialized by `getFileReadCache`. */
+    fileReadCache?: import("../edit/file-read-cache").FileReadCache;
+    /** Per-session log of unresolved git merge conflict regions surfaced by
+     *  `read`. Each entry gets a stable id N referenced by `write conflict://N`
+     *  to splice the recorded region with replacement content. Lazily initialized
+     *  by `getConflictHistory`. */
+    conflictHistory?: import("./conflict-detect").ConflictHistory;
+    /** Queue a hidden message to be injected at the next agent turn. */
+    queueDeferredMessage?(message: CustomMessage): void;
+    /** Get the active OpenTelemetry config so subagent dispatch can forward
+     *  the parent's tracer/hooks with the subagent's own identity stamped. */
+    getTelemetry?: () => AgentTelemetryConfig | undefined;
+}
+export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
+export type BuiltinToolLoadMode = "essential" | "discoverable";
+/** Default essential tool names when tools.essentialOverride is empty. */
+export declare const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[];
+/**
+ * Resolve the active essential built-in tool names from settings.
+ * Returns `tools.essentialOverride` if non-empty (filtered to known built-ins),
+ * otherwise `DEFAULT_ESSENTIAL_TOOL_NAMES`.
+ */
+export declare function computeEssentialBuiltinNames(settings: Settings): string[];
+/**
+ * Public callable factory map. External callers may invoke `BUILTIN_TOOLS.read(session)` or
+ * `BUILTIN_TOOLS[name](session)` to construct a tool directly.
+ */
+export declare const BUILTIN_TOOLS: Record<string, ToolFactory>;
+export declare const HIDDEN_TOOLS: Record<string, ToolFactory>;
+export type ToolName = keyof typeof BUILTIN_TOOLS;
+export interface EvalBackendsAllowance {
+    python: boolean;
+    js: boolean;
+}
+/** Read per-backend allowance from settings (defaults true). */
+export declare function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAllowance;
+/**
+ * Materialize the active eval backend allowance: PI_PY / PI_JS env flags
+ * override the per-key settings; otherwise settings (defaults true) win.
+ */
+export declare function resolveEvalBackends(session: ToolSession): EvalBackendsAllowance;
+/**
+ * Create tools from BUILTIN_TOOLS registry.
+ */
+export declare function createTools(session: ToolSession, toolNames?: string[]): Promise<Tool[]>;

package/dist/types/tools/inspect-image-renderer.d.ts

@@ -0,0 +1,26 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+interface InspectImageRenderArgs {
+    path?: string;
+    question?: string;
+}
+interface InspectImageRendererDetails {
+    model: string;
+    imagePath: string;
+    mimeType: string;
+}
+interface InspectImageRendererResult {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: InspectImageRendererDetails;
+    isError?: boolean;
+}
+export declare const inspectImageToolRenderer: {
+    renderCall(args: InspectImageRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: InspectImageRendererResult, options: RenderResultOptions, uiTheme: Theme, args?: InspectImageRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/inspect-image.d.ts

@@ -0,0 +1,31 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { completeSimple } from "@oh-my-pi/pi-ai";
+import * as z from "zod/v4";
+import type { ToolSession } from "./index";
+declare const inspectImageSchema: z.ZodObject<{
+    path: z.ZodString;
+    question: z.ZodString;
+}, z.core.$strict>;
+export type InspectImageParams = z.infer<typeof inspectImageSchema>;
+export interface InspectImageToolDetails {
+    model: string;
+    imagePath: string;
+    mimeType: string;
+}
+export declare class InspectImageTool implements AgentTool<typeof inspectImageSchema, InspectImageToolDetails> {
+    private readonly session;
+    private readonly completeImageRequest;
+    readonly name = "inspect_image";
+    readonly label = "InspectImage";
+    readonly loadMode = "discoverable";
+    readonly summary = "Describe or analyze an image file";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        path: z.ZodString;
+        question: z.ZodString;
+    }, z.core.$strict>;
+    readonly strict = false;
+    constructor(session: ToolSession, completeImageRequest?: typeof completeSimple);
+    execute(_toolCallId: string, params: InspectImageParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<InspectImageToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<InspectImageToolDetails>>;
+}
+export { inspectImageToolRenderer } from "./inspect-image-renderer";

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

@@ -0,0 +1,79 @@
+/**
+ * IRC tool — agent-to-agent messaging.
+ *
+ * Lets any live agent send a short prose message to any other live agent in
+ * this process and (optionally) get a prose reply.
+ *
+ * Routing happens via the global AgentRegistry. Replies are produced by an
+ * ephemeral side-channel call (`AgentSession.respondAsBackground`) that
+ * mirrors `/btw`: the recipient's current model, system prompt, and message
+ * history are used to compute a reply without persisting it through the
+ * normal stream path. After the reply is generated, both the incoming
+ * message and the auto-reply are queued for injection into the recipient's
+ * persisted history (deferred until the recipient is idle), so the model
+ * sees the exchange on its next turn.
+ *
+ * This avoids the deadlock that arises when the recipient is blocked on a
+ * long-running tool call: the side-channel call does not depend on the
+ * recipient's main agent loop being free.
+ */
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+declare const ircSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        list: "list";
+        send: "send";
+    }>;
+    to: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    awaitReply: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type IrcParams = z.infer<typeof ircSchema>;
+interface IrcReply {
+    from: string;
+    text: string;
+}
+export interface IrcDetails {
+    op: "send" | "list";
+    from?: string;
+    to?: string;
+    delivered?: string[];
+    replies?: IrcReply[];
+    failed?: Array<{
+        id: string;
+        error: string;
+    }>;
+    notFound?: string[];
+    peers?: Array<{
+        id: string;
+        displayName: string;
+        kind: string;
+        status: string;
+        parentId?: string;
+    }>;
+    channels?: string[];
+}
+export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
+    #private;
+    private readonly session;
+    readonly name = "irc";
+    readonly label = "IRC";
+    readonly summary = "Send and receive messages between agents over IRC-like channels";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        op: z.ZodEnum<{
+            list: "list";
+            send: "send";
+        }>;
+        to: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        awaitReply: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): IrcTool | null;
+    execute(_toolCallId: string, params: IrcParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<IrcDetails>, _context?: AgentToolContext): Promise<AgentToolResult<IrcDetails>>;
+}
+export {};

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

@@ -0,0 +1,65 @@
+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 { ToolSession } from "./index";
+declare const jobSchema: z.ZodObject<{
+    poll: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cancel: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    list: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type JobParams = z.infer<typeof jobSchema>;
+interface JobSnapshot {
+    id: string;
+    type: "bash" | "task";
+    status: "running" | "completed" | "failed" | "cancelled";
+    label: string;
+    durationMs: number;
+    resultText?: string;
+    errorText?: string;
+}
+type CancelStatus = "cancelled" | "not_found" | "already_completed";
+export interface JobToolDetails {
+    jobs: JobSnapshot[];
+    cancelled?: {
+        id: string;
+        status: CancelStatus;
+    }[];
+}
+export declare class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "job";
+    readonly label = "Job";
+    readonly summary = "Manage long-running background jobs (async bash/python)";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        poll: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        cancel: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        list: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): JobTool | null;
+    execute(_toolCallId: string, params: JobParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<JobToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<JobToolDetails>>;
+}
+interface JobRenderArgs {
+    poll?: string[];
+    cancel?: string[];
+}
+export declare const jobToolRenderer: {
+    inline: boolean;
+    renderCall(args: JobRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: JobToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: JobRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/json-tree.d.ts

@@ -0,0 +1,23 @@
+import type { Theme } from "../modes/theme/theme";
+/** Max depth for JSON tree rendering */
+export declare const JSON_TREE_MAX_DEPTH_COLLAPSED = 2;
+export declare const JSON_TREE_MAX_DEPTH_EXPANDED = 6;
+export declare const JSON_TREE_MAX_LINES_COLLAPSED = 6;
+export declare const JSON_TREE_MAX_LINES_EXPANDED = 200;
+export declare const JSON_TREE_SCALAR_LEN_COLLAPSED = 60;
+export declare const JSON_TREE_SCALAR_LEN_EXPANDED = 2000;
+/**
+ * Format a scalar value for inline display.
+ */
+export declare function formatScalar(value: unknown, maxLen: number): string;
+/**
+ * Format args inline for collapsed view.
+ */
+export declare function formatArgsInline(args: Record<string, unknown>, maxWidth: number): string;
+/**
+ * Render a JSON value as tree lines.
+ */
+export declare function renderJsonTreeLines(value: unknown, theme: Theme, maxDepth: number, maxLines: number, maxScalarLen: number): {
+    lines: string[];
+    truncated: boolean;
+};

package/dist/types/tools/jtd-to-json-schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Convert JSON Type Definition (JTD) to JSON Schema.
+ *
+ * JTD (RFC 8927) is a simpler schema format. This converter allows users to
+ * write schemas in JTD and have them converted to JSON Schema for model APIs.
+ *
+ * @see https://jsontypedef.com/
+ * @see https://datatracker.ietf.org/doc/html/rfc8927
+ */
+/**
+ * Detect if a schema is JTD format (vs JSON Schema).
+ *
+ * JTD schemas use: type (primitives), properties, optionalProperties, elements, values, enum, discriminator, ref
+ * JSON Schema uses: type: "object", type: "array", items, additionalProperties, etc.
+ */
+export declare function isJTDSchema(schema: unknown): boolean;
+/**
+ * Convert JTD schema to JSON Schema.
+ * If already JSON Schema, returns as-is.
+ */
+export declare function jtdToJsonSchema(schema: unknown): unknown;
+/**
+ * Normalize a schema input that may be a JSON string, object, or null/undefined.
+ * Returns { normalized } on success, or { error } if JSON parsing fails.
+ */
+export declare function normalizeSchema(schema: unknown): {
+    normalized?: unknown;
+    error?: string;
+};

package/dist/types/tools/jtd-to-typescript.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Convert JSON Type Definition (JTD) to TypeScript interface notation.
+ *
+ * Produces human-readable TypeScript for embedding in system prompts,
+ * helping models understand expected output structure.
+ */
+/**
+ * Convert JTD schema to TypeScript interface string.
+ *
+ * @example
+ * ```ts
+ * const schema = {
+ *   properties: {
+ *     name: { type: "string" },
+ *     count: { type: "int32" }
+ *   }
+ * };
+ * jtdToTypeScript(schema);
+ * // Returns:
+ * // {
+ * //   name: string;
+ * //   count: number;
+ * // }
+ * ```
+ */
+export declare function jtdToTypeScript(schema: unknown): string;

package/dist/types/tools/jtd-utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * JSON Type Definition (JTD) utility types and guards.
+ *
+ * Shared type definitions and type guard functions for JTD schema validation.
+ *
+ * @see https://jsontypedef.com/
+ * @see https://datatracker.ietf.org/doc/html/rfc8927
+ */
+export type JTDPrimitive = "boolean" | "string" | "timestamp" | "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32";
+export interface JTDType {
+    type: JTDPrimitive;
+}
+export interface JTDEnum {
+    enum: string[];
+}
+export interface JTDElements {
+    elements: JTDSchema;
+}
+export interface JTDValues {
+    values: JTDSchema;
+}
+export interface JTDProperties {
+    properties?: Record<string, JTDSchema>;
+    optionalProperties?: Record<string, JTDSchema>;
+}
+export interface JTDDiscriminator {
+    discriminator: string;
+    mapping: Record<string, JTDProperties>;
+}
+export interface JTDRef {
+    ref: string;
+}
+export interface JTDEmpty {
+}
+export type JTDSchema = JTDType | JTDEnum | JTDElements | JTDValues | JTDProperties | JTDDiscriminator | JTDRef | JTDEmpty;
+export declare function isJTDType(schema: unknown): schema is JTDType;
+export declare function isJTDEnum(schema: unknown): schema is JTDEnum;
+export declare function isJTDElements(schema: unknown): schema is JTDElements;
+export declare function isJTDValues(schema: unknown): schema is JTDValues;
+export declare function isJTDProperties(schema: unknown): schema is JTDProperties;
+export declare function isJTDDiscriminator(schema: unknown): schema is JTDDiscriminator;
+export declare function isJTDRef(schema: unknown): schema is JTDRef;

package/dist/types/tools/list-limit.d.ts

@@ -0,0 +1,12 @@
+import type { LimitsMeta } from "./output-meta";
+export interface ListLimitResult<T> {
+    items: T[];
+    limitReached?: number;
+    meta: Partial<LimitsMeta>;
+}
+export interface ListLimitOptions {
+    limit?: number;
+    headLimit?: number;
+    limitType?: "match" | "result";
+}
+export declare function applyListLimit<T>(items: T[], options: ListLimitOptions): ListLimitResult<T>;

package/dist/types/tools/match-line-format.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Format a single line of match output for grep/ast-grep style results.
+ *
+ * The anchor/content separator is always `|`. Matched lines are prefixed
+ * with `*`; context lines are prefixed with a single space so anchors
+ * align in column. In hashline mode the anchor is `LINE+ID` (no `#`); in
+ * plain mode it is just the line number. Line numbers are never padded.
+ */
+export declare function formatMatchLine(lineNumber: number, line: string, isMatch: boolean, options: {
+    useHashLines: boolean;
+}): string;