jeopi-cli 16.2.14 → 16.2.15

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

@@ -0,0 +1,112 @@
+/**
+ * IRC tool — agent-to-agent messaging over the process-global IrcBus.
+ *
+ * `send` is fire-and-forget: the bus routes the message to the recipient
+ * (waking idle agents with a real turn, reviving parked ones via the
+ * lifecycle manager, injecting a non-interrupting aside into busy ones) and
+ * returns delivery receipts immediately. Replies are real turns by the
+ * recipient, observed with `wait` (or the `await: true` send sugar). `inbox`
+ * drains pending messages; `list` shows every addressable peer.
+ */
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
+import type { ToolExample } from "jeopi-ai";
+import { type Component } from "jeopi-tui";
+import type { Settings } from "../config/settings";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type IrcDeliveryReceipt, type IrcMessage } from "../irc/bus";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+/**
+ * IRC availability: there must be someone to chat with. True for every
+ * subagent (it always has a parent, and possibly siblings) and for any
+ * session that can still spawn subagents through the task tool. Only a
+ * top-level session with task spawning unavailable has no peers — no irc.
+ */
+export declare function isIrcEnabled(settings: Settings, taskDepth: number): boolean;
+declare const ircSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op: "inbox" | "list" | "send" | "wait";
+    to?: string | undefined;
+    message?: string | undefined;
+    replyTo?: string | undefined;
+    await?: boolean | undefined;
+    from?: string | undefined;
+    timeoutMs?: number | undefined;
+    peek?: boolean | undefined;
+}, {}>;
+type IrcParams = typeof ircSchema.infer;
+interface IrcPeerInfo {
+    id: string;
+    displayName: string;
+    kind: string;
+    status: string;
+    parentId?: string;
+    unread: number;
+    lastActivity: number;
+    activity?: string;
+}
+export interface IrcDetails {
+    op: "send" | "wait" | "inbox" | "list";
+    from?: string;
+    to?: string;
+    receipts?: IrcDeliveryReceipt[];
+    /** Message consumed by `wait` / `send await:true`; null when the wait timed out. */
+    waited?: IrcMessage | null;
+    inbox?: IrcMessage[];
+    peers?: IrcPeerInfo[];
+}
+export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
+    #private;
+    private readonly session;
+    readonly name = "irc";
+    readonly approval: "read";
+    readonly label = "IRC";
+    readonly summary = "Send and receive messages between agents";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        op: "inbox" | "list" | "send" | "wait";
+        to?: string | undefined;
+        message?: string | undefined;
+        replyTo?: string | undefined;
+        await?: boolean | undefined;
+        from?: string | undefined;
+        timeoutMs?: number | undefined;
+        peek?: boolean | undefined;
+    }, {}>;
+    readonly strict = true;
+    readonly interruptible = true;
+    readonly examples: readonly ToolExample<typeof ircSchema.infer>[];
+    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>>;
+}
+type IrcRenderArgs = Partial<IrcParams>;
+/**
+ * Display-only transcript card for live IRC traffic: `irc:incoming` DMs
+ * delivered to this session, `irc:autoreply` side-channel replies sent on
+ * this session's behalf, and `irc:relay` observations of agent↔agent
+ * traffic. Shares the tool renderer's glyph + quote-border conventions so
+ * cards and `irc` tool output look identical in the transcript.
+ */
+export declare function createIrcMessageCard(card: {
+    kind: "incoming" | "autoreply" | "relay";
+    from?: string;
+    to?: string;
+    body?: string;
+    replyTo?: string;
+    timestamp?: number;
+}, getExpanded: () => boolean, uiTheme: Theme): Component;
+export declare const ircToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: IrcRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: IrcDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: IrcRenderArgs): Component;
+};
+export {};

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

@@ -0,0 +1,73 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } 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 { ToolSession } from "./index";
+declare const jobSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    poll?: string[] | undefined;
+    cancel?: string[] | undefined;
+    list?: boolean | undefined;
+}, {}>;
+type JobParams = typeof jobSchema.infer;
+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;
+    }[];
+}
+/**
+ * A poll snapshot where every watched job is still running and nothing was
+ * cancelled — pure "still waiting" noise once a newer poll exists. The TUI
+ * keeps such a block un-finalized (displaceable) so a follow-up `job` call
+ * replaces it instead of stacking another waiting frame in the transcript.
+ */
+export declare function isWaitingPollDetails(details: unknown): boolean;
+export declare class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "job";
+    readonly approval: "read";
+    readonly label = "Job";
+    readonly summary = "Manage long-running background jobs (async bash/python)";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        poll?: string[] | undefined;
+        cancel?: string[] | undefined;
+        list?: boolean | undefined;
+    }, {}>;
+    readonly strict = true;
+    readonly interruptible = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: JobParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<JobToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<JobToolDetails>>;
+}
+interface JobRenderArgs {
+    poll?: string[];
+    cancel?: string[];
+    list?: boolean;
+}
+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/learn.d.ts

@@ -0,0 +1,44 @@
+import type { AgentTool, AgentToolResult } from "jeopi-agent-core";
+import type { ToolSession } from ".";
+declare const learnSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    memory: string;
+    context?: string | undefined;
+    skill?: {
+        action: "create" | "update";
+        name: string;
+        description: string;
+        body: string;
+    } | undefined;
+}, {}>;
+export type LearnParams = typeof learnSchema.infer;
+/**
+ * Orchestrating "learn" tool: persists a lesson to long-term memory and,
+ * given a `skill` payload, mints/enhances a managed skill via the shared
+ * `writeManagedSkill` primitive. Gated behind `autolearn.enabled` plus a live
+ * memory backend — `hindsight`/`mnemopi` (remote/SQLite) or `local` (the
+ * file-based rollout backend, where lessons append to `learned.md`).
+ */
+export declare class LearnTool implements AgentTool<typeof learnSchema> {
+    private readonly session;
+    readonly name = "learn";
+    readonly approval: (args: unknown) => "read" | "write";
+    readonly label = "Learn";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        memory: string;
+        context?: string | undefined;
+        skill?: {
+            action: "create" | "update";
+            name: string;
+            description: string;
+            body: string;
+        } | undefined;
+    }, {}>;
+    readonly strict = true;
+    readonly loadMode: "essential";
+    readonly summary = "Capture a reusable lesson to memory (and optionally a managed skill)";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): LearnTool | null;
+    execute(_id: string, params: LearnParams): Promise<AgentToolResult>;
+}
+export {};

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/manage-skill.d.ts

@@ -0,0 +1,31 @@
+import type { AgentTool, AgentToolResult } from "jeopi-agent-core";
+import type { ToolSession } from ".";
+declare const manageSkillSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    action: "create" | "delete" | "update";
+    name: string;
+    description?: string | undefined;
+    body?: string | undefined;
+}, {}>;
+export type ManageSkillParams = typeof manageSkillSchema.infer;
+/**
+ * Direct create/update/delete of isolated managed skills. Gated behind
+ * `autolearn.enabled`; backend-independent (the skill side is standalone).
+ */
+export declare class ManageSkillTool implements AgentTool<typeof manageSkillSchema> {
+    readonly name = "manage_skill";
+    readonly approval: "write";
+    readonly label = "Manage Skill";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        action: "create" | "delete" | "update";
+        name: string;
+        description?: string | undefined;
+        body?: string | undefined;
+    }, {}>;
+    readonly strict = true;
+    readonly loadMode: "essential";
+    readonly summary = "Create, update, or delete an isolated managed skill";
+    static createIf(session: ToolSession): ManageSkillTool | null;
+    execute(_id: string, params: ManageSkillParams): Promise<AgentToolResult>;
+}
+export {};

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.
+ *
+ * Matched lines are prefixed with `*`; context lines are prefixed with a single
+ * space so line numbers align in column. In hashline mode the line uses the
+ * editable `LINE:content` shape under a snapshot-tag header; in plain mode it
+ * keeps the legacy `LINE|content` display-only shape. Line numbers are never padded.
+ */
+export declare function formatMatchLine(lineNumber: number, line: string, isMatch: boolean, options: {
+    useHashLines: boolean;
+}): string;

package/dist/types/tools/memory-edit.d.ts

@@ -0,0 +1,31 @@
+import type { AgentTool, AgentToolResult } from "jeopi-agent-core";
+import type { ToolSession } from ".";
+declare const memoryEditSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op: "forget" | "invalidate" | "update";
+    id: string;
+    content?: string | undefined;
+    importance?: number | undefined;
+    replacement_id?: string | undefined;
+}, {}>;
+export type MemoryEditParams = typeof memoryEditSchema.infer;
+export declare class MemoryEditTool implements AgentTool<typeof memoryEditSchema> {
+    private readonly session;
+    readonly name = "memory_edit";
+    readonly approval: "read";
+    readonly label = "Memory Edit";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        op: "forget" | "invalidate" | "update";
+        id: string;
+        content?: string | undefined;
+        importance?: number | undefined;
+        replacement_id?: string | undefined;
+    }, {}>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly summary = "Update, forget, or invalidate Mnemopi memories";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): MemoryEditTool | null;
+    execute(_id: string, params: MemoryEditParams): Promise<AgentToolResult>;
+}
+export {};

package/dist/types/tools/memory-recall.d.ts

@@ -0,0 +1,23 @@
+import type { AgentTool, AgentToolResult } from "jeopi-agent-core";
+import type { ToolSession } from ".";
+declare const memoryRecallSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    query: string;
+}, {}>;
+export type MemoryRecallParams = typeof memoryRecallSchema.infer;
+export declare class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
+    private readonly session;
+    readonly name = "recall";
+    readonly approval: "read";
+    readonly label = "Recall";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        query: string;
+    }, {}>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly summary = "Search memory for relevant prior context";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): MemoryRecallTool | null;
+    execute(_id: string, params: MemoryRecallParams, signal?: AbortSignal): Promise<AgentToolResult>;
+}
+export {};

package/dist/types/tools/memory-reflect.d.ts

@@ -0,0 +1,25 @@
+import type { AgentTool, AgentToolResult } from "jeopi-agent-core";
+import type { ToolSession } from ".";
+declare const memoryReflectSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    query: string;
+    context?: string | undefined;
+}, {}>;
+export type MemoryReflectParams = typeof memoryReflectSchema.infer;
+export declare class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema> {
+    private readonly session;
+    readonly name = "reflect";
+    readonly approval: "read";
+    readonly label = "Reflect";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        query: string;
+        context?: string | undefined;
+    }, {}>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly summary = "Synthesize an answer from long-term memory";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): MemoryReflectTool | null;
+    execute(_id: string, params: MemoryReflectParams, signal?: AbortSignal): Promise<AgentToolResult>;
+}
+export {};

package/dist/types/tools/memory-render.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Inline TUI renderers for the long-term memory tools (`retain`, `recall`,
+ * `reflect`).
+ *
+ * These keep the transcript terse — one status line plus, for `retain`, one
+ * `Remember: …` line per stored item — instead of the generic JSON arg tree,
+ * which exploded multi-line memory blobs into an unreadable wall. The tool
+ * container is a transparent passthrough, so these renderers stay frameless:
+ * a status line with a couple of dim bullets reads far cleaner than boxing a
+ * one-line memory note.
+ */
+import type { Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+interface RetainRenderArgs {
+    items?: Array<{
+        content?: string;
+        context?: string;
+    }>;
+}
+interface QueryRenderArgs {
+    query?: string;
+}
+export declare const retainToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: RetainRenderArgs, options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: {
+            count?: number;
+        };
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: RetainRenderArgs): Component;
+};
+export declare const recallToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: QueryRenderArgs): Component;
+};
+export declare const reflectToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: QueryRenderArgs): Component;
+};
+export {};

package/dist/types/tools/memory-retain.d.ts

@@ -0,0 +1,29 @@
+import type { AgentTool, AgentToolResult } from "jeopi-agent-core";
+import type { ToolSession } from ".";
+declare const memoryRetainSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    items: {
+        content: string;
+        context?: string | undefined;
+    }[];
+}, {}>;
+export type MemoryRetainParams = typeof memoryRetainSchema.infer;
+export declare class MemoryRetainTool implements AgentTool<typeof memoryRetainSchema> {
+    private readonly session;
+    readonly name = "retain";
+    readonly approval: "read";
+    readonly label = "Retain";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        items: {
+            content: string;
+            context?: string | undefined;
+        }[];
+    }, {}>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly summary = "Store important facts in long-term memory";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): MemoryRetainTool | null;
+    execute(_id: string, params: MemoryRetainParams): Promise<AgentToolResult>;
+}
+export {};