jeopi-cli 16.2.14 → 16.2.17

package/dist/types/edit/modes/patch.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Patch application logic for the edit tool.
+ *
+ * Applies parsed diff hunks to file content using fuzzy matching
+ * for robust handling of whitespace and formatting differences.
+ */
+import type { AgentToolResult } from "jeopi-agent-core";
+import { type WritethroughCallback, type WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+import type { EditToolDetails, LspBatchRequest } from "../renderer";
+export type Operation = "create" | "delete" | "update";
+export interface PatchInput {
+    path: string;
+    op: Operation;
+    rename?: string;
+    diff?: string;
+}
+export interface FileSystem {
+    exists(path: string): Promise<boolean>;
+    read(path: string): Promise<string>;
+    readBinary?: (path: string) => Promise<Uint8Array>;
+    write(path: string, content: string): Promise<void>;
+    delete(path: string): Promise<void>;
+    mkdir(path: string): Promise<void>;
+}
+interface FileChange {
+    type: Operation;
+    path: string;
+    newPath?: string;
+    oldContent?: string;
+    newContent?: string;
+}
+export interface ApplyPatchResult {
+    change: FileChange;
+    warnings?: string[];
+}
+export interface ApplyPatchOptions {
+    cwd: string;
+    dryRun?: boolean;
+    fuzzyThreshold?: number;
+    allowFuzzy?: boolean;
+    fs?: FileSystem;
+    /**
+     * Permit `op: "create"` to replace an existing file (full-file overwrite).
+     * The JSON `patch` edit mode sanctions create-as-overwrite for major
+     * restructures (see prompts/tools/patch.md); the Codex `apply_patch`
+     * envelope documents `*** Add File` as strictly non-overwriting and must
+     * leave this unset.
+     */
+    allowCreateOverwrite?: boolean;
+}
+/** Default filesystem implementation using Bun APIs */
+export declare const defaultFileSystem: FileSystem;
+/**
+ * Apply a patch operation to the filesystem.
+ */
+export declare function applyPatch(input: PatchInput, options: ApplyPatchOptions): Promise<ApplyPatchResult>;
+/**
+ * Preview what changes a patch would make without applying it.
+ */
+export declare function previewPatch(input: PatchInput, options: ApplyPatchOptions): Promise<ApplyPatchResult>;
+export declare function computePatchDiff(input: PatchInput, cwd: string, options?: {
+    fuzzyThreshold?: number;
+    allowFuzzy?: boolean;
+    allowCreateOverwrite?: boolean;
+}): Promise<{
+    diff: string;
+    firstChangedLine: number | undefined;
+} | {
+    error: string;
+}>;
+export declare const patchEditEntrySchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op?: "create" | "delete" | "update" | undefined;
+    rename?: string | undefined;
+    diff?: string | undefined;
+}, {}>;
+export type PatchEditEntry = typeof patchEditEntrySchema.infer;
+export declare const patchEditSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    path: string;
+    edits: {
+        op?: "create" | "delete" | "update" | undefined;
+        rename?: string | undefined;
+        diff?: string | undefined;
+    }[];
+}, {}>;
+export type PatchParams = typeof patchEditSchema.infer;
+export interface ExecutePatchSingleOptions {
+    session: ToolSession;
+    path: string;
+    params: PatchEditEntry;
+    signal?: AbortSignal;
+    batchRequest?: LspBatchRequest;
+    allowFuzzy: boolean;
+    fuzzyThreshold: number;
+    /** See {@link ApplyPatchOptions.allowCreateOverwrite}; set by the JSON `patch` mode only. */
+    allowCreateOverwrite?: boolean;
+    writethrough: WritethroughCallback;
+    beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+}
+export declare function executePatchSingle(options: ExecutePatchSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof patchEditEntrySchema>>;
+export {};

package/dist/types/edit/modes/replace.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Fuzzy matching utilities for the edit tool.
+ *
+ * Provides both character-level and line-level fuzzy matching with progressive
+ * fallback strategies for finding text in files.
+ */
+import type { AgentToolResult } from "jeopi-agent-core";
+import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+import type { EditToolDetails, LspBatchRequest } from "../renderer";
+export interface FuzzyMatch {
+    actualText: string;
+    startIndex: number;
+    startLine: number;
+    confidence: number;
+}
+export interface MatchOutcome {
+    match?: FuzzyMatch;
+    closest?: FuzzyMatch;
+    occurrences?: number;
+    occurrenceLines?: number[];
+    occurrencePreviews?: string[];
+    fuzzyMatches?: number;
+    dominantFuzzy?: boolean;
+}
+export type SequenceMatchStrategy = "exact" | "trim-trailing" | "trim" | "comment-prefix" | "unicode" | "prefix" | "substring" | "fuzzy" | "fuzzy-dominant" | "character";
+export interface SequenceSearchResult {
+    index: number | undefined;
+    confidence: number;
+    matchCount?: number;
+    matchIndices?: number[];
+    strategy?: SequenceMatchStrategy;
+}
+export type ContextMatchStrategy = "exact" | "trim" | "unicode" | "prefix" | "substring" | "fuzzy";
+export interface ContextLineResult {
+    index: number | undefined;
+    confidence: number;
+    matchCount?: number;
+    matchIndices?: number[];
+    strategy?: ContextMatchStrategy;
+}
+export declare class EditMatchError extends Error {
+    readonly path: string;
+    readonly searchText: string;
+    readonly closest: FuzzyMatch | undefined;
+    readonly options: {
+        allowFuzzy: boolean;
+        threshold: number;
+        fuzzyMatches?: number;
+    };
+    constructor(path: string, searchText: string, closest: FuzzyMatch | undefined, options: {
+        allowFuzzy: boolean;
+        threshold: number;
+        fuzzyMatches?: number;
+    });
+    static formatMessage(path: string, searchText: string, closest: FuzzyMatch | undefined, options: {
+        allowFuzzy: boolean;
+        threshold: number;
+        fuzzyMatches?: number;
+    }): string;
+}
+/** Default similarity threshold for fuzzy matching */
+export declare const DEFAULT_FUZZY_THRESHOLD = 0.95;
+/** Compute Levenshtein distance between two strings */
+export declare function levenshteinDistance(a: string, b: string): number;
+/** Compute similarity score between two strings (0 to 1) */
+export declare function similarity(a: string, b: string): number;
+/**
+ * Find a match for target text within content.
+ * Used primarily for replace-mode edits.
+ */
+export declare function findMatch(content: string, target: string, options: {
+    allowFuzzy: boolean;
+    threshold?: number;
+}): MatchOutcome;
+/**
+ * Find a sequence of pattern lines within content lines.
+ *
+ * Attempts matches with decreasing strictness:
+ * 1. Exact match
+ * 2. Trailing whitespace ignored
+ * 3. All whitespace trimmed
+ * 4. Unicode punctuation normalized
+ * 5. Prefix match (pattern is prefix of line)
+ * 6. Substring match (pattern is substring of line)
+ * 7. Fuzzy similarity match
+ *
+ * @param lines - The lines of the file content
+ * @param pattern - The lines to search for
+ * @param start - Starting index for the search
+ * @param eof - If true, prefer matching at end of file first
+ */
+export declare function seekSequence(lines: string[], pattern: string[], start: number, eof: boolean, options?: {
+    allowFuzzy?: boolean;
+}): SequenceSearchResult;
+export declare function findClosestSequenceMatch(lines: string[], pattern: string[], options?: {
+    start?: number;
+    eof?: boolean;
+}): {
+    index: number | undefined;
+    confidence: number;
+    strategy: SequenceMatchStrategy;
+};
+/**
+ * Find a context line in the file using progressive matching strategies.
+ *
+ * @param lines - The lines of the file content
+ * @param context - The context line to search for
+ * @param startFrom - Starting index for the search
+ */
+export declare function findContextLine(lines: string[], context: string, startFrom: number, options?: {
+    allowFuzzy?: boolean;
+    skipFunctionFallback?: boolean;
+}): ContextLineResult;
+export declare const replaceEditEntrySchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    old_text: string;
+    new_text: string;
+    all?: boolean | undefined;
+}, {}>;
+export declare const replaceEditSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    path: string;
+    edits: {
+        old_text: string;
+        new_text: string;
+        all?: boolean | undefined;
+    }[];
+}, {}>;
+export type ReplaceEditEntry = typeof replaceEditEntrySchema.infer;
+export type ReplaceParams = typeof replaceEditSchema.infer;
+export interface ExecuteReplaceSingleOptions {
+    session: ToolSession;
+    path: string;
+    params: ReplaceEditEntry;
+    signal?: AbortSignal;
+    batchRequest?: LspBatchRequest;
+    allowFuzzy: boolean;
+    fuzzyThreshold: number;
+    writethrough: WritethroughCallback;
+    beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+}
+export declare function executeReplaceSingle(options: ExecuteReplaceSingleOptions): Promise<AgentToolResult<EditToolDetails, ReplaceEditEntry>>;

package/dist/types/edit/normalize.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Text normalization utilities for the edit tool.
+ *
+ * Whitespace, Unicode, and indentation helpers. Line-ending and BOM
+ * primitives live in `jeopi-hashline` and are re-exported here so
+ * existing consumers see one stable surface.
+ */
+export { type BomResult, detectLineEnding, type LineEnding, normalizeToLF, restoreLineEndings, stripBom, } from "jeopi-hashline";
+/** Count leading whitespace characters in a line */
+export declare function countLeadingWhitespace(line: string): number;
+/** Get the leading whitespace string from a line */
+export declare function getLeadingWhitespace(line: string): string;
+/** Compute minimum indentation of non-empty lines */
+export declare function minIndent(text: string): number;
+/** Detect the indentation character used in text (space or tab) */
+export declare function detectIndentChar(text: string): string;
+export declare function convertLeadingTabsToSpaces(text: string, spacesPerTab: number): string;
+export declare function normalizeUnicode(s: string): string;
+/**
+ * Normalize a line for fuzzy comparison.
+ * Trims, collapses whitespace, and normalizes punctuation.
+ */
+export declare function normalizeForFuzzy(line: string): string;
+/**
+ * Adjust newText indentation to match the indentation delta between
+ * what was provided (oldText) and what was actually matched (actualText).
+ *
+ * If oldText has 0 indent but actualText has 12 spaces, we add 12 spaces
+ * to each line in newText.
+ */
+export declare function adjustIndentation(oldText: string, actualText: string, newText: string): string;

package/dist/types/edit/notebook.d.ts

@@ -0,0 +1,23 @@
+export type NotebookCellType = "code" | "markdown" | "raw";
+export interface NotebookCell {
+    cell_type: NotebookCellType;
+    source?: string | string[];
+    metadata?: Record<string, unknown>;
+    execution_count?: number | null;
+    outputs?: unknown[];
+    [key: string]: unknown;
+}
+export interface NotebookDocument {
+    cells: NotebookCell[];
+    metadata: Record<string, unknown>;
+    nbformat: number;
+    nbformat_minor: number;
+    [key: string]: unknown;
+}
+export declare function isNotebookPath(filePath: string): boolean;
+export declare function splitNotebookSource(content: string): string[];
+export declare function readNotebookDocument(absolutePath: string, displayPath: string): Promise<NotebookDocument>;
+export declare function notebookToEditableText(notebook: NotebookDocument): string;
+export declare function applyNotebookEditableText(notebook: NotebookDocument, text: string, displayPath: string): NotebookDocument;
+export declare function readEditableNotebookText(absolutePath: string, displayPath: string): Promise<string>;
+export declare function serializeEditedNotebookText(absolutePath: string, displayPath: string, text: string): Promise<string>;

package/dist/types/edit/read-file.d.ts

@@ -0,0 +1,2 @@
+export declare function readEditFileText(absolutePath: string, path: string): Promise<string>;
+export declare function serializeEditFileText(absolutePath: string, path: string, content: string): Promise<string>;

package/dist/types/edit/renderer.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Edit tool renderer and LSP batching helpers.
+ */
+import type { Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { FileDiagnosticsResult } from "../lsp";
+import { type Theme } from "../modes/theme/theme";
+import type { OutputMeta } from "../tools/output-meta";
+import { getLspBatchRequest, type LspBatchRequest } from "../tools/render-utils";
+import type { EditMode } from "../utils/edit-mode";
+import type { DiffError, DiffResult } from "./diff";
+import type { Operation } from "./modes/patch";
+import type { PerFileDiffPreview } from "./streaming";
+export { getLspBatchRequest, type LspBatchRequest };
+export interface EditToolPerFileResult {
+    path: string;
+    diff: string;
+    firstChangedLine?: number;
+    diagnostics?: FileDiagnosticsResult;
+    op?: Operation;
+    move?: string;
+    isError?: boolean;
+    errorText?: string;
+    /** TUI-friendly error text. When present, rendered to the user instead of `errorText`.
+     * Set when the underlying error carries a `displayMessage` (e.g. {@link HashlineMismatchError}). */
+    displayErrorText?: string;
+    meta?: OutputMeta;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
+    /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+    sourcePath?: string;
+}
+export interface EditToolDetails {
+    /** Unified diff of the changes made */
+    diff: string;
+    /** Line number of the first change in the new file (for editor navigation) */
+    firstChangedLine?: number;
+    /** Diagnostic result (if available) */
+    diagnostics?: FileDiagnosticsResult;
+    /** Operation type (patch mode only) */
+    op?: Operation;
+    /** New path after move/rename (patch mode only) */
+    move?: string;
+    /** Structured output metadata */
+    meta?: OutputMeta;
+    /** Per-file results (multi-file edits) */
+    perFileResults?: EditToolPerFileResult[];
+    /** Absolute file path for single-file edit results. Required by ACP diff metadata consumers. */
+    path?: string;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
+    /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+    sourcePath?: string;
+}
+interface EditRenderArgs {
+    path?: string;
+    file_path?: string;
+    oldText?: string;
+    newText?: string;
+    patch?: string;
+    input?: string;
+    all?: boolean;
+    op?: Operation;
+    rename?: string;
+    diff?: string;
+    /**
+     * Computed preview diff (used when tool args don't include a diff, e.g. hashline mode).
+     */
+    previewDiff?: string;
+    __partialJson?: string;
+    edits?: EditRenderEntry[];
+}
+type EditRenderEntry = {
+    path?: string;
+    rename?: string;
+    move?: string;
+    op?: Operation;
+};
+/** Extended context for edit tool rendering */
+export interface EditRenderContext {
+    /** Edit mode resolved by the caller; lets the renderer dispatch without shape-sniffing */
+    editMode?: EditMode;
+    /** Pre-computed diff preview (computed before tool executes) */
+    editDiffPreview?: DiffResult | DiffError;
+    /** Multi-file streaming diff preview (edits spanning several files) */
+    perFileDiffPreview?: PerFileDiffPreview[];
+    /** Raw in-flight edit text shown while a computed diff preview is unavailable */
+    editStreamingFallback?: string;
+    /** Function to render diff text with syntax highlighting */
+    renderDiff?: (diffText: string, options?: {
+        filePath?: string;
+    }) => string;
+}
+export declare const editToolRenderer: {
+    mergeCallAndResult: boolean;
+    provisionalPendingPreview: boolean;
+    renderCall(args: EditRenderArgs, options: RenderResultOptions & {
+        renderContext?: EditRenderContext;
+    }, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: EditToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: EditRenderContext;
+    }, uiTheme: Theme, args?: EditRenderArgs): Component;
+};

package/dist/types/edit/snapshot-details.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bound the size of the `oldText` / `newText` snapshots that edit-tool results
+ * carry in `details`. These fields hold the full pre/post file content; for
+ * large files they balloon the per-turn JSONL line and the session file
+ * (300 KB+ each on the cases reported in #3786) without paying for any LLM
+ * context (provider serializers send only `content`, never `details`).
+ *
+ * Only consumer of the raw snapshots is the ACP event mapper, which builds a
+ * `diff` ToolCallContent for ACP clients (Zed). When the snapshots are pruned
+ * the mapper returns `undefined` for that file and the text content still
+ * flows — diff visualization degrades gracefully for over-threshold edits.
+ */
+import type { EditToolDetails, EditToolPerFileResult } from "./renderer";
+/**
+ * Combined `oldText` + `newText` character budget for a single edit-tool
+ * result. Applies both per-entry (one file at a time) and as an aggregate
+ * across `perFileResults` (so a many-small-files batch can't accumulate
+ * unbounded snapshot bytes — see #3787 review).
+ *
+ * Picked so typical code-file edits keep ACP diff visualization while
+ * pathological cases (large generated files, full-file rewrites, or
+ * many-file batches) drop the raw snapshots before they hit the
+ * session JSONL.
+ */
+export declare const MAX_EDIT_SNAPSHOT_TEXT_CHARS = 32768;
+/**
+ * Prune oversized `oldText` / `newText` from an edit-tool details payload,
+ * recursing into `perFileResults` when present. Per-file overload comes first
+ * so the more specific shape (required `path`) wins overload resolution at
+ * the per-file call sites.
+ */
+export declare function pruneOversizedEditSnapshots(details: EditToolPerFileResult): EditToolPerFileResult;
+export declare function pruneOversizedEditSnapshots(details: EditToolDetails): EditToolDetails;

package/dist/types/edit/streaming.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Streaming edit preview strategies.
+ *
+ * Each edit mode owns a strategy that knows how to:
+ * - collapse partial-JSON args to the subset safe to preview
+ *   (`extractCompleteEdits`),
+ * - compute unified diff previews for the in-flight args
+ *   (`computeDiffPreview`), and
+ * - render a text placeholder while no diff exists yet
+ *   (`renderStreamingFallback`).
+ *
+ * The shared renderer / `ToolExecutionComponent` consult the strategy via
+ * the injected `editMode` rather than probing argument shape.
+ */
+import { type SnapshotStore } from "jeopi-hashline";
+import type { Theme } from "../modes/theme/theme";
+import { type EditMode, resolveEditMode } from "../utils/edit-mode";
+export interface PerFileDiffPreview {
+    path: string;
+    diff?: string;
+    firstChangedLine?: number;
+    error?: string;
+}
+export interface StreamingDiffContext {
+    cwd: string;
+    signal: AbortSignal;
+    snapshots: SnapshotStore;
+    fuzzyThreshold?: number;
+    allowFuzzy?: boolean;
+    /**
+     * True while the tool's arguments are still streaming in. Strategies that
+     * accept free-form text input (apply_patch, hashline) trim the trailing
+     * partial line so per-character growth of an in-flight `+added` line does
+     * not flicker in the preview.
+     */
+    isStreaming?: boolean;
+}
+/**
+ * Per-file projection of a streamed edit payload. Pairs one target file path
+ * with the digest of only the lines added to that file, so path-scoped stream
+ * matchers (TTSR) evaluate each file in isolation — a `tool:edit(*.ts)` rule
+ * never fires on text that actually belongs to a sibling `README.md` hunk.
+ */
+export interface EditMatcherEntry {
+    readonly path: string;
+    readonly digest: string;
+}
+export interface EditStreamingStrategy<Args = unknown> {
+    /**
+     * Return the args restricted to edits that are "complete enough" to
+     * compute a diff against. Strategies drop the trailing incomplete entry
+     * when `partialJson` indicates its closing `}` hasn't arrived yet.
+     */
+    extractCompleteEdits(args: Args, partialJson: string | undefined): Args;
+    /**
+     * Compute diff(s) for the given partial args. Returns `null` when args
+     * do not yet carry enough structure to compute anything.
+     */
+    computeDiffPreview(args: Args, ctx: StreamingDiffContext): Promise<PerFileDiffPreview[] | null>;
+    /**
+     * Rendered inline while the diff hasn't been computed yet (or when the
+     * compute returned `null` because args are still too partial).
+     */
+    renderStreamingFallback(args: Args, uiTheme: Theme): string;
+    /**
+     * Project the (potentially partial) args onto the plain text the edit
+     * introduces into files — added lines without patch grammar — so stream
+     * matchers (TTSR rules) can run source-level patterns against real content
+     * instead of the mode-specific wire format. Returns `undefined` when the
+     * args don't yet carry any content.
+     */
+    matcherDigest(args: Args): string | undefined;
+    /**
+     * Surface the target file paths a (potentially partial) call would touch,
+     * so path-scoped stream matchers (e.g. TTSR `tool:edit(*.ts)` globs) match
+     * even when the path is not a top-level argument but lives inside the wire
+     * payload — `hashline` section headers, `apply_patch` envelope markers.
+     * Returns `undefined` (or an empty list) when no paths are recoverable.
+     */
+    matcherPaths(args: Args): readonly string[] | undefined;
+    /**
+     * Per-file projection of the (potentially partial) args: one entry per
+     * touched file pairing the path with the digest of only the lines added to
+     * that file. Multi-file payloads (multi-section hashline / multi-hunk
+     * apply_patch) MUST split here so callers can evaluate each file under its
+     * own path scope instead of leaking added lines from one file into the
+     * other's match context. Same-path sections / hunks are merged into one
+     * entry. Returns `undefined` (or empty) when no per-file split is
+     * recoverable yet — the caller falls back to {@link matcherDigest} +
+     * {@link matcherPaths}.
+     */
+    matcherEntries(args: Args): readonly EditMatcherEntry[] | undefined;
+}
+/**
+ * Given an edits array parsed from partial JSON, drop the last entry when the
+ * corresponding object in `partialJson` has not yet closed with `}`.
+ *
+ * The streaming parser materializes a trailing edit object from the fields seen
+ * so far before its closing `}` arrives, so an unfinished last entry can render
+ * as a (partial) edit mid-stream. Dropping it until the object closes keeps the
+ * preview from showing an incomplete edit.
+ */
+export declare function dropIncompleteLastEdit<T>(edits: readonly T[], partialJson: string | undefined, listKey: string): T[];
+export declare const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>>;
+export { resolveEditMode };

package/dist/types/eval/__tests__/agent-bridge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/__tests__/bridge-timeout.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/__tests__/budget-bridge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/__tests__/completion-bridge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/__tests__/helpers-local-roots.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/__tests__/idle-timeout.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/__tests__/js-context-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/__tests__/julia-prelude.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/__tests__/kernel-spawn.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/__tests__/prelude-agent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/eval/agent-bridge.d.ts

@@ -0,0 +1,48 @@
+import { type NestedRepoPatch } from "../task/worktree";
+import type { ToolSession } from "../tools";
+import type { JsStatusEvent } from "./js/shared/types";
+import "../tools/review";
+/** Synthetic bridge name reserved for the `agent()` helper across both runtimes. */
+export declare const EVAL_AGENT_BRIDGE_NAME = "__agent__";
+/**
+ * Hard recursion ceiling for eval-driven subagents. The user setting
+ * `task.maxRecursionDepth` is honored on top of this — whichever is tighter
+ * wins, so a maintainer-friendly cap can't get raised by a user setting.
+ */
+export declare const EVAL_AGENT_MAX_DEPTH = 3;
+export interface EvalAgentBridgeOptions {
+    session: ToolSession;
+    signal?: AbortSignal;
+    emitStatus?: (event: JsStatusEvent) => void;
+}
+export interface EvalAgentResult {
+    text: string;
+    details: {
+        agent: string;
+        id: string;
+        model?: string | string[];
+        structured: boolean;
+        /** True iff this run executed inside an isolation worktree. */
+        isolated?: boolean;
+        /** Captured patch artifact (patch mode) — surfaced regardless of `apply`. */
+        patchPath?: string;
+        /** Captured branch (branch mode) — surfaced regardless of `apply`. */
+        branchName?: string;
+        /** Captured nested repository patches — surfaced for isolated `apply=false` manual application. */
+        nestedPatches?: NestedRepoPatch[];
+        /**
+         * Tri-state apply outcome for isolated runs:
+         * - `true`  — apply ran (or had nothing to do) and left the repo clean.
+         * - `false` — apply attempted and failed; artifacts preserved.
+         * - `null`  — caller opted out via `apply=false`.
+         * Omitted for non-isolated runs.
+         */
+        changesApplied?: boolean | null;
+        /** Human-readable isolation apply/merge summary; kept out of schema-backed `text`. */
+        isolationSummary?: string;
+    };
+}
+/**
+ * Run a single subagent on behalf of an eval cell's `agent()` call.
+ */
+export declare function runEvalAgent(args: unknown, options: EvalAgentBridgeOptions): Promise<EvalAgentResult>;

package/dist/types/eval/backend-helpers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Helpers shared by the per-language eval backend definitions (jl/js/py/rb
+ * index modules): session-id namespacing, settings access, and projection of
+ * executor results into the ExecutorBackend result shape.
+ */
+import type { ToolSession } from "../tools";
+import type { ExecutorBackendResult } from "./backend";
+import type { EvalDisplayOutput } from "./types";
+export declare function namespaceSessionId(sessionId: string, prefix: string): string;
+export declare function readSetting<T>(session: ToolSession, key: string): T | undefined;
+export declare function readInterpreterSetting(session: ToolSession, key: string): string | undefined;
+export declare function toExecutorBackendResult(result: {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    artifactId?: string | undefined;
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    displayOutputs: EvalDisplayOutput[];
+}): ExecutorBackendResult;