@sayknow-cli/coding-agent 0.4.2 → 0.4.3

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

@@ -0,0 +1,99 @@
+/**
+ * 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 "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+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;
+}
+/** 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;
+}): Promise<{
+    diff: string;
+    firstChangedLine: number | undefined;
+} | {
+    error: string;
+}>;
+export declare const patchEditEntrySchema: z.ZodObject<{
+    op: z.ZodOptional<z.ZodEnum<{
+        delete: "delete";
+        create: "create";
+        update: "update";
+    }>>;
+    rename: z.ZodOptional<z.ZodString>;
+    diff: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const patchEditSchema: z.ZodObject<{
+    path: z.ZodString;
+    edits: z.ZodArray<z.ZodObject<{
+        op: z.ZodOptional<z.ZodEnum<{
+            delete: "delete";
+            create: "create";
+            update: "update";
+        }>>;
+        rename: z.ZodOptional<z.ZodString>;
+        diff: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PatchEditEntry = z.infer<typeof patchEditEntrySchema>;
+export type PatchParams = z.infer<typeof patchEditSchema>;
+export interface ExecutePatchSingleOptions {
+    session: ToolSession;
+    path: string;
+    params: PatchEditEntry;
+    signal?: AbortSignal;
+    batchRequest?: LspBatchRequest;
+    allowFuzzy: boolean;
+    fuzzyThreshold: number;
+    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,149 @@
+/**
+ * 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 "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+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;
+interface BestFuzzyMatchResult {
+    best?: FuzzyMatch;
+    aboveThresholdCount: number;
+    secondBestScore: number;
+}
+export declare function findBestFuzzyMatch(content: string, target: string, threshold: number): BestFuzzyMatchResult;
+/**
+ * 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: z.ZodObject<{
+    old_text: z.ZodString;
+    new_text: z.ZodString;
+    all: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const replaceEditSchema: z.ZodObject<{
+    path: z.ZodString;
+    edits: z.ZodArray<z.ZodObject<{
+        old_text: z.ZodString;
+        new_text: z.ZodString;
+        all: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReplaceEditEntry = z.infer<typeof replaceEditEntrySchema>;
+export type ReplaceParams = z.infer<typeof replaceEditSchema>;
+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, typeof replaceEditEntrySchema>>;
+export {};

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

@@ -0,0 +1,43 @@
+/**
+ * Text normalization utilities for the edit tool.
+ *
+ * Handles line endings, BOM, whitespace, and Unicode normalization.
+ */
+export type LineEnding = "\r\n" | "\n";
+/** Detect the predominant line ending in content */
+export declare function detectLineEnding(content: string): LineEnding;
+/** Normalize all line endings to LF */
+export declare function normalizeToLF(text: string): string;
+/** Restore line endings to the specified type */
+export declare function restoreLineEndings(text: string, ending: LineEnding): string;
+export interface BomResult {
+    /** The BOM character if present, empty string otherwise */
+    bom: string;
+    /** The text without the BOM */
+    text: string;
+}
+/** Strip UTF-8 BOM if present */
+export declare function stripBom(content: string): BomResult;
+/** 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,26 @@
+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 createNotebookCell(cellType: NotebookCellType, source: string): NotebookCell;
+export declare function createEmptyNotebook(): NotebookDocument;
+export declare function serializeNotebookDocument(notebook: NotebookDocument): 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,8 @@
+/**
+ * Max byte size of a file the edit modes will load whole. Editing loads + normalizes +
+ * fuzzy-matches + diffs the entire file on the main thread, so a multi-MB/generated file
+ * would block the event loop (F19). Above this, fail fast with an actionable error.
+ */
+export declare const MAX_EDIT_FILE_BYTES: number;
+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,110 @@
+/**
+ * Edit tool renderer and LSP batching helpers.
+ */
+import type { Component } from "@sayknow-cli/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 VimRenderArgs } from "../tools/vim";
+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;
+}
+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;
+}
+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;
+    renderCall(args: EditRenderArgs | VimRenderArgs, 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/streaming.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 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 { 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;
+    fuzzyThreshold?: number;
+    allowFuzzy?: boolean;
+    hashlineAutoDropPureInsertDuplicates?: 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;
+}
+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;
+}
+/**
+ * Given an edits array parsed from partial JSON, drop the last entry when the
+ * corresponding object in `partialJson` does not yet end with a closed `}`.
+ *
+ * This guards against `partial-json` silently coercing truncated tails like
+ * `"write":nu` / `"write":nul` into `{ write: null }`, which would make the
+ * last entry render a spurious null-write error until the value finishes
+ * streaming.
+ */
+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/backend.d.ts

@@ -0,0 +1,40 @@
+import type { ToolSession } from "../tools";
+import type { EvalDisplayOutput, EvalLanguage } from "./types";
+/** Per-cell execute() options. */
+export interface ExecutorBackendExecOptions {
+    cwd: string;
+    sessionId: string;
+    sessionFile: string | undefined;
+    kernelOwnerId: string | undefined;
+    signal?: AbortSignal;
+    session: ToolSession;
+    deadlineMs: number;
+    reset: boolean;
+    artifactPath: string | undefined;
+    artifactId: string | undefined;
+    onChunk: (chunk: string) => void;
+}
+/** Result returned by a backend's execute(). */
+export interface ExecutorBackendResult {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    artifactId: string | undefined;
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    displayOutputs: EvalDisplayOutput[];
+}
+/** Pluggable language backend for the eval tool. */
+export interface ExecutorBackend {
+    readonly id: EvalLanguage;
+    readonly label: string;
+    /** Source language identifier passed to the syntax highlighter (e.g. "python", "javascript"). */
+    readonly highlightLang: string;
+    /** Cheap availability check. Used by fallback resolution. */
+    isAvailable(session: ToolSession): Promise<boolean>;
+    /** Execute one cell. Caller invokes once per cell and aggregates results. */
+    execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
+}

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

@@ -0,0 +1,4 @@
+export * from "./backend";
+export { default as jsBackend } from "./js";
+export { default as pythonBackend } from "./py";
+export * from "./types";

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

@@ -0,0 +1,27 @@
+import type { ToolSession } from "../../tools";
+import type { JsDisplayOutput } from "./worker-protocol";
+export { rewriteImports, wrapCode } from "./shared/rewrite-imports";
+export type { JsDisplayOutput } from "./worker-protocol";
+export interface VmRunState {
+    signal?: AbortSignal;
+    onText?: (chunk: string) => void;
+    onDisplay?: (output: JsDisplayOutput) => void;
+}
+export declare function executeInVmContext(options: {
+    sessionKey: string;
+    sessionId: string;
+    cwd: string;
+    session: ToolSession;
+    ownerId?: string;
+    reset?: boolean;
+    code: string;
+    filename: string;
+    timeoutMs?: number;
+    runState: VmRunState;
+}): Promise<{
+    value: unknown;
+}>;
+export declare function resetVmContext(sessionKey: string): Promise<void>;
+export declare function disposeVmContextsByOwner(ownerId: string): Promise<void>;
+export declare function disposeAllVmContexts(): Promise<void>;
+export declare function liveVmContextCount(): number;

package/dist/types/eval/js/executor.d.ts

@@ -0,0 +1,29 @@
+import type { ToolSession } from "../../tools";
+import { type JsDisplayOutput } from "./context-manager";
+export interface JsExecutorOptions {
+    cwd?: string;
+    timeoutMs?: number;
+    deadlineMs?: number;
+    onChunk?: (chunk: string) => Promise<void> | void;
+    signal?: AbortSignal;
+    sessionId: string;
+    ownerId?: string;
+    reset?: boolean;
+    sessionFile?: string;
+    artifactPath?: string;
+    artifactId?: string;
+    session: ToolSession;
+}
+export interface JsResult {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    artifactId?: string;
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    displayOutputs: JsDisplayOutput[];
+}
+export declare function executeJs(code: string, options: JsExecutorOptions): Promise<JsResult>;

package/dist/types/eval/js/index.d.ts

@@ -0,0 +1,10 @@
+import type { ToolSession } from "../../tools";
+import type { ExecutorBackendExecOptions, ExecutorBackendResult } from "../backend";
+declare const _default: {
+    id: "js";
+    label: string;
+    highlightLang: string;
+    isAvailable(_session: ToolSession): Promise<boolean>;
+    execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
+};
+export default _default;

package/dist/types/eval/js/shared/helpers.d.ts

@@ -0,0 +1,38 @@
+import type { JsStatusEvent } from "./types";
+export interface HelperOptions {
+    path?: string;
+    hidden?: boolean;
+    maxDepth?: number;
+    limit?: number;
+    offset?: number;
+    reverse?: boolean;
+    unique?: boolean;
+    count?: boolean;
+}
+/**
+ * Inputs the helper factory needs from its host runtime. `cwd` is a getter so the runtime
+ * can update it between cells (e.g. when the agent's session cwd changes) without
+ * recreating helpers.
+ */
+export interface HelperContext {
+    cwd(): string;
+    env: Map<string, string>;
+    emitStatus(event: JsStatusEvent): void;
+}
+/**
+ * The set of functions exposed to user code via `globalThis.__skc_helpers__`. The JS
+ * prelude reads from this bag and attaches short aliases (`read`, `write`, `tree`, ...)
+ * onto the global scope.
+ */
+export interface HelperBundle {
+    read(rawPath: string, options?: HelperOptions): Promise<string>;
+    writeFile(rawPath: string, data: unknown): Promise<string>;
+    append(rawPath: string, content: string): Promise<string>;
+    sortText(text: string, options?: HelperOptions): string;
+    uniqText(text: string, options?: HelperOptions): string | Array<[number, string]>;
+    counter(items: string | string[], options?: HelperOptions): Array<[number, string]>;
+    diff(rawA: string, rawB: string): Promise<string>;
+    tree(searchPath?: string, options?: HelperOptions): Promise<string>;
+    env(key?: string, value?: string): string | Record<string, string> | undefined;
+}
+export declare function createHelpers(ctx: HelperContext): HelperBundle;

package/dist/types/eval/js/shared/indirect-eval.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Indirect eval — runs in the host's global scope, isolating bindings declared with
+ * `const`/`let` from this module's closure. Used by both the JS eval worker and the
+ * browser tab worker to execute user-supplied source without `node:vm`.
+ *
+ * Why not vm.runInContext: Bun crashes the parent process with SIGTRAP when
+ * `Worker.terminate()` fires while a worker is mid-`vm.runInContext` synchronous loop.
+ * Indirect eval does not trip that bug.
+ *
+ * The optional `filename` is appended as a `//# sourceURL=...` pragma so V8 attributes
+ * stack frames to the user cell instead of `<anonymous>`.
+ */
+export declare function indirectEval(source: string, filename?: string): unknown;
+export declare function awaitMaybePromise<T>(value: T | Promise<T>): Promise<T>;

package/dist/types/eval/js/shared/prelude.d.ts

@@ -0,0 +1 @@
+export declare const JAVASCRIPT_PRELUDE_SOURCE: string;