@sayknow-cli/coding-agent 0.3.16 → 0.4.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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