jeopi-cli 16.2.13 → 16.2.14

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

@@ -1,112 +0,0 @@
-/**
- * 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

@@ -1,73 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,29 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,42 +0,0 @@
-/**
- * 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

@@ -1,44 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,31 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,63 +0,0 @@
-/**
- * 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

@@ -1,29 +0,0 @@
-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 {};