@giovannijecha/jecode 0.8.5 → 0.8.7

package/dist/settings.js

@@ -1,11 +1,11 @@
-// Persistent, non-secret defaults for interactive and batch sessions.
+// Persistent, non-secret defaults for interactive sessions.
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
 import { assertDirectoryAnchor, captureDirectDirectorySync, preparePrivateDirectory, } from "./directory-anchor.js";
 import { MAX_COMPACTION_PERCENT, MIN_COMPACTION_PERCENT } from "./context/policy.js";
 import { EFFORTS } from "./effort.js";
 import { providerNames } from "./providers/index.js";
-import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
+import { isLegacyOllamaCloudHost, OLLAMA_CLOUD_HOST } from "./providers/ollama-endpoint.js";
 import { withStoreLock } from "./store-lock.js";
 import { userDataLabel, userDataPath } from "./user-data.js";
 import { assertStoreText, readBoundedJsonForMutationSync, readBoundedJsonSync, USER_STORE_LIMITS, } from "./user-store.js";
@@ -17,12 +17,14 @@ export function readSettings() {
     return copy(saved);
 }
 export async function updateSettings(patch) {
+    assertRetiredOllamaHost(patch);
     const file = settingsPath();
     const directory = path.dirname(file);
     const anchor = await preparePrivateDirectory(directory, "settings store directory");
     const anchoredFile = path.join(anchor.path, path.basename(file));
     return withStoreLock(anchoredFile, async () => {
         const next = normalize({ ...readStoreForMutation(anchoredFile, anchor), ...patch });
+        delete next.ollamaHost;
         const text = `${JSON.stringify(next, null, 2)}\n`;
         assertStoreText(text, USER_STORE_LIMITS.settingsBytes);
         await atomicWrite(anchoredFile, text, {
@@ -50,8 +52,8 @@ function readStore(file = settingsPath()) {
         return normalize(readBoundedJsonSync(anchoredFile, USER_STORE_LIMITS.settingsBytes, directory));
     }
     catch {
-        // Missing, unreadable, and malformed stores all fall back safely. A bad
-        // preference must never prevent the agent from starting.
+        // Missing, unreadable, and malformed stores fall back safely. Parsed
+        // retired endpoint markers survive normalization for startup validation.
         return {};
     }
 }
@@ -88,9 +90,7 @@ function assertMutableSettings(value) {
             Object.values(models).some((model) => !boundedNonempty(model, USER_STORE_LIMITS.model)))
             throw new Error("settings store has invalid models");
     }
-    if ("ollamaHost" in value && endpoint(value["ollamaHost"]) === undefined) {
-        throw new Error("settings store has an invalid Ollama endpoint");
-    }
+    assertRetiredOllamaHost(value);
     if ("effort" in value && member(value["effort"], EFFORTS) === undefined) {
         throw new Error("settings store has an invalid reasoning effort");
     }
@@ -109,7 +109,7 @@ function normalize(value) {
     const providers = providerNames();
     const provider = member(value["provider"], providers);
     const models = modelsOf(value["models"], providers);
-    const ollamaHost = endpoint(value["ollamaHost"]);
+    const ollamaHost = "ollamaHost" in value ? legacyOllamaHost(value["ollamaHost"]) : undefined;
     const effort = member(value["effort"], EFFORTS);
     const reducedMotion = typeof value["reducedMotion"] === "boolean" ? value["reducedMotion"] : undefined;
     const maxTokens = positiveInteger(value["maxTokens"]);
@@ -133,14 +133,15 @@ function modelsOf(value, providers) {
 function member(value, values) {
     return typeof value === "string" && values.includes(value) ? value : undefined;
 }
-function endpoint(value) {
-    if (!boundedNonempty(value, USER_STORE_LIMITS.endpoint))
-        return undefined;
-    try {
-        return parseOllamaEndpoint(value).baseUrl;
-    }
-    catch {
-        return undefined;
+function legacyOllamaHost(value) {
+    if (isLegacyOllamaCloudHost(value))
+        return OLLAMA_CLOUD_HOST;
+    // Even an invalid retired value must not disappear and enable cloud use.
+    return boundedNonempty(value, USER_STORE_LIMITS.endpoint) ? value : "unsupported legacy Ollama endpoint";
+}
+function assertRetiredOllamaHost(value) {
+    if ("ollamaHost" in value && !isLegacyOllamaCloudHost(value.ollamaHost)) {
+        throw new Error("settings store has a retired Ollama endpoint; remove ollamaHost from settings.json to use Ollama API");
     }
 }
 function boundedNonempty(value, max) {

package/dist/start.js

@@ -1,12 +1,11 @@
-// Application bootstrap: resolve one session, then choose its terminal surface.
+// Application bootstrap: validate the terminal and resolve one interactive session.
 import * as path from "node:path";
-import { runBatch } from "./batch.js";
 import { showCliInfo } from "./cli-info.js";
 import { loadConfig } from "./config.js";
 import { ConversationTree } from "./conversation.js";
 import { parseLaunch } from "./launch.js";
 import { systemPrompt } from "./prompt.js";
-import { configureProviders, selectProvider } from "./providers/index.js";
+import { selectProvider } from "./providers/index.js";
 import { SessionPersistence } from "./sessions/runtime.js";
 import { DurableSessionStore } from "./sessions/store.js";
 import { builtinTools } from "./tools/index.js";
@@ -22,23 +21,17 @@ export async function start(args = process.argv.slice(2), environment = {}) {
     if (await showCliInfo(args, applicationRoot, write))
         return;
     const launch = parseLaunch(args);
-    const config = loadConfig(launch.configArgs);
-    configureProviders(config);
-    const provider = selectProvider(config.providerId);
     const hasScreen = environment.interactive?.() ?? interactive();
-    if (launch.kind === "resume" && !hasScreen) {
-        throw new Error("resume needs an interactive terminal");
+    if (!hasScreen) {
+        throw new Error("an interactive terminal is required on stdin and stdout; run jecode directly without pipes or redirection");
     }
+    const config = loadConfig(launch.configArgs, environment.readSettings?.());
+    const provider = selectProvider(config.providerId);
     if (launch.kind === "resume" && config.ephemeral) {
         throw new Error("--ephemeral cannot be combined with resume");
     }
-    // A provider whose catalogue is not fixed has no sensible default model.
-    // The TUI can ask; a pipe cannot, so batch mode still requires one up front.
     const model = config.model === "" ? provider.defaultModel : config.model;
-    if (model === "" && !hasScreen) {
-        throw new Error(`${provider.id} has no default model — pass --model <id> (or set JECODE_MODEL)`);
-    }
-    configureColor(hasScreen);
+    configureColor(true);
     const session = {
         config,
         provider,
@@ -49,52 +42,42 @@ export async function start(args = process.argv.slice(2), environment = {}) {
         conversation: ConversationTree.empty(),
         usage: emptyUsage(),
     };
-    if (hasScreen) {
-        if (!config.ephemeral) {
-            const store = await DurableSessionStore.open(config.root, environment.sessionsRoot);
-            if (launch.kind === "resume") {
-                const candidates = await SessionPersistence.candidates(store);
-                if (candidates.length === 0)
-                    throw new Error("no resumable sessions found for this workspace");
-                const open = async (id) => {
-                    const resumed = await SessionPersistence.resume(store, id);
-                    try {
-                        applyResumedSession(session, resumed.conversation, resumed.persistence);
-                    }
-                    catch (error) {
-                        await resumed.persistence.close();
-                        throw error;
-                    }
-                };
-                if (launch.latest)
-                    await open(candidates[0].id);
-                else
-                    session.resume = { candidates, open };
-            }
-            else {
-                session.persistence = SessionPersistence.fresh(store);
-            }
+    if (!config.ephemeral) {
+        const store = await DurableSessionStore.open(config.root, environment.sessionsRoot);
+        if (launch.kind === "resume") {
+            const candidates = await SessionPersistence.candidates(store);
+            if (candidates.length === 0)
+                throw new Error("no resumable sessions found for this workspace");
+            const open = async (id) => {
+                const resumed = await SessionPersistence.resume(store, id);
+                try {
+                    applyResumedSession(session, resumed.conversation, resumed.persistence);
+                }
+                catch (error) {
+                    await resumed.persistence.close();
+                    throw error;
+                }
+            };
+            if (launch.latest)
+                await open(candidates[0].id);
+            else
+                session.resume = { candidates, open };
         }
-        try {
-            if (environment.runInteractive === undefined) {
-                await runApp(session, transcriptRoot, { shutdownSignal: environment.signal });
-            }
-            else {
-                await environment.runInteractive(session, transcriptRoot, environment.signal);
-            }
-        }
-        finally {
-            await session.persistence?.close();
+        else {
+            session.persistence = SessionPersistence.fresh(store);
         }
     }
-    else {
-        if (environment.runNonInteractive === undefined) {
-            await runBatch(session, { signal: environment.signal });
+    try {
+        if (environment.runInteractive === undefined) {
+            await runApp(session, transcriptRoot, { shutdownSignal: environment.signal });
         }
         else {
-            await environment.runNonInteractive(session, environment.signal);
+            await environment.runInteractive(session, transcriptRoot, environment.signal);
         }
     }
+    finally {
+        await session.persistence?.close();
+    }
 }
 function applyResumedSession(session, conversation, persistence) {
     const identity = conversation.activeNode?.identity;

package/dist/timeline.js

@@ -16,6 +16,8 @@ export function timelinePicker(conversation, palette) {
             searchable: true,
             query: "",
             visible: 8,
+            // Turn labels are previews; keep each node on its own row without a second copy.
+            overflow: "truncate",
             options: entries.map((entry) => ({
                 label: `${entry.prefix}${preview(entry.node)}`,
                 hint: stamp(entry.node.createdAt),

package/dist/tools/file-read.js

@@ -0,0 +1,192 @@
+// Bounded workspace file reads and stable directory listings.
+import * as path from "node:path";
+import { withStableFile } from "../bounded-file.js";
+import { readStableDirectory } from "../stable-directory.js";
+import { optionalInt, optionalString, requireString } from "./args.js";
+import { resolveExistingInRoot } from "./paths.js";
+import { leadingText } from "./text-boundary.js";
+import { count, plural } from "./file-summary.js";
+const MAX_READ_CHARS = 60_000;
+const MAX_LIST_CHARS = 60_000;
+const MAX_LIST_ENTRIES = 2_000;
+const READ_CHUNK_BYTES = 64 * 1024;
+const MAX_READ_SCAN_BYTES = 16 * 1024 * 1024;
+export const readFile = {
+    name: "read_file",
+    description: "Read a regular UTF-8 text file inside the workspace. Optionally start at a line " +
+        "(1-based) and cap how many lines come back. Large files are truncated.",
+    dangerous: false,
+    concurrency: "shared",
+    input: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path relative to the workspace root." },
+            offset: { type: "integer", description: "First line to return, 1-based." },
+            limit: { type: "integer", description: "How many lines to return." },
+        },
+        required: ["path"],
+    },
+    async run(args, ctx) {
+        return runReadFile(args, ctx);
+    },
+};
+export async function runReadFile(args, ctx, dependencies = {}) {
+    const root = await resolveExistingInRoot(ctx.root, ".");
+    const target = await resolveExistingInRoot(root, requireString(args, "path"));
+    const offset = optionalInt(args, "offset");
+    const limit = optionalInt(args, "limit");
+    const { text, truncated, scanCapped } = await readRange(root, target, offset, limit, ctx.signal, dependencies);
+    if (truncated) {
+        return {
+            output: `${text}\n\n[truncated at ${MAX_READ_CHARS} characters — read a narrower range]`,
+            summary: `truncated at ${MAX_READ_CHARS} characters`,
+        };
+    }
+    if (scanCapped) {
+        const notice = `[read stopped after scanning ${MAX_READ_SCAN_BYTES} bytes — use a smaller offset or search_text]`;
+        return {
+            output: text === "" ? notice : `${text}\n\n${notice}`,
+            summary: `scan capped at ${MAX_READ_SCAN_BYTES} bytes`,
+        };
+    }
+    if (text === "")
+        return { output: "[file is empty]", summary: "empty" };
+    return { output: text, summary: `${count(text, "line")}` };
+}
+export const listDir = {
+    name: "list_dir",
+    description: "List the entries of a directory inside the workspace. Directories end with a slash.",
+    dangerous: false,
+    concurrency: "shared",
+    input: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Directory relative to the workspace root. Defaults to the root." },
+        },
+        required: [],
+    },
+    async run(args, ctx) {
+        return runListDir(args, ctx);
+    },
+};
+export async function runListDir(args, ctx, dependencies = {}) {
+    const root = await resolveExistingInRoot(ctx.root, ".");
+    const requested = optionalString(args, "path");
+    const relative = requested === undefined || requested.trim() === "" ? "." : requested;
+    const target = await resolveExistingInRoot(root, relative);
+    const inspected = await readStableDirectory(root, target, {
+        maxEntries: MAX_LIST_ENTRIES + 1,
+        signal: ctx.signal,
+        beforeOpen: dependencies.beforeOpen,
+    });
+    const entries = [];
+    let chars = 0;
+    let truncated = inspected.capped;
+    for (const entry of inspected.entries) {
+        const label = entry.kind === "directory" ? `${entry.name}/` : entry.name;
+        const separator = entries.length === 0 ? 0 : 1;
+        if (entries.length >= MAX_LIST_ENTRIES ||
+            chars + separator + label.length > MAX_LIST_CHARS) {
+            truncated = true;
+            break;
+        }
+        entries.push(label);
+        chars += separator + label.length;
+    }
+    if (entries.length === 0)
+        return { output: "[empty directory]", summary: "empty" };
+    const listing = entries.join("\n");
+    if (truncated) {
+        return {
+            output: `${listing}\n\n[truncated after ${entries.length} entries]`,
+            summary: `${entries.length}+ entries`,
+        };
+    }
+    return { output: listing, summary: plural(entries.length, "entry", "entries") };
+}
+async function readRange(root, target, offset, limit, signal, dependencies) {
+    throwIfAborted(signal);
+    const firstLine = Math.max(1, offset ?? 1);
+    const lineCount = limit === undefined ? undefined : Math.max(0, limit);
+    const endLine = lineCount === undefined ? Number.POSITIVE_INFINITY : firstLine + lineCount;
+    if (lineCount === 0)
+        return { text: "", truncated: false, scanCapped: false };
+    const result = await withStableFile(target, {
+        label: "read file",
+        signal,
+        beforeOpen: dependencies.beforeOpen,
+    }, async (handle, opened) => {
+        const decoder = new TextDecoder();
+        let text = "";
+        let line = 1;
+        let stopped = false;
+        let truncated = false;
+        let reachedEnd = false;
+        const selected = (at) => at >= firstLine && at < endLine;
+        const append = (fragment) => {
+            if (fragment === "")
+                return;
+            const room = MAX_READ_CHARS - text.length;
+            if (fragment.length > room) {
+                text += leadingText(fragment, room);
+                truncated = true;
+                stopped = true;
+                return;
+            }
+            text += fragment;
+        };
+        const consume = (chunk) => {
+            let start = 0;
+            while (!stopped && start < chunk.length) {
+                const newline = chunk.indexOf("\n", start);
+                const end = newline === -1 ? chunk.length : newline;
+                if (selected(line))
+                    append(chunk.slice(start, end));
+                if (stopped || newline === -1)
+                    return;
+                const nextLine = line + 1;
+                if (selected(line) && selected(nextLine))
+                    append("\n");
+                line = nextLine;
+                if (line >= endLine) {
+                    stopped = true;
+                    return;
+                }
+                start = newline + 1;
+            }
+        };
+        let position = 0;
+        const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+        while (!stopped && position < MAX_READ_SCAN_BYTES) {
+            throwIfAborted(signal);
+            const length = Math.min(buffer.length, MAX_READ_SCAN_BYTES - position);
+            const { bytesRead } = await handle.read(buffer, 0, length, position);
+            throwIfAborted(signal);
+            if (bytesRead === 0) {
+                reachedEnd = true;
+                break;
+            }
+            position += bytesRead;
+            consume(decoder.decode(buffer.subarray(0, bytesRead), { stream: true }));
+        }
+        if (!stopped && BigInt(position) >= opened.size)
+            reachedEnd = true;
+        if (!stopped && reachedEnd)
+            consume(decoder.decode());
+        return {
+            text,
+            truncated,
+            scanCapped: !stopped && !reachedEnd && position >= MAX_READ_SCAN_BYTES,
+        };
+    });
+    const confirmed = await resolveExistingInRoot(root, target);
+    if (path.relative(target, confirmed) !== "") {
+        throw new Error("read file changed while it was being read");
+    }
+    return result;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}

package/dist/tools/file-summary.js

@@ -0,0 +1,9 @@
+// Shared line and entry counts in filesystem tool summaries.
+export function count(text, noun) {
+    if (text === "")
+        return "empty";
+    return plural(text.split("\n").length, noun, `${noun}s`);
+}
+export function plural(n, one, many) {
+    return `${n} ${n === 1 ? one : many}`;
+}

package/dist/tools/{fs.js → file-write.js}

@@ -1,111 +1,12 @@
-// Filesystem tools: read, list, write, edit.
+// Atomic file mutations share preview validation and exact replacement rules.
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { withStableFile } from "../bounded-file.js";
-import { readStableDirectory } from "../stable-directory.js";
-import { optionalBool, optionalInt, optionalString, requireString } from "./args.js";
-import { assertDirectWritableInRoot, displayPath, resolveDirectWritableInRoot, resolveExistingInRoot, } from "./paths.js";
-import { assertEditableText, assertReplacementFits, leadingText, MAX_EDITABLE_CHARS, MAX_EDITABLE_LINES, readEditableText, } from "./text-boundary.js";
 import { atomicWrite } from "../atomic.js";
-const MAX_READ_CHARS = 60_000;
-const MAX_LIST_CHARS = 60_000;
-const MAX_LIST_ENTRIES = 2_000;
-const READ_CHUNK_BYTES = 64 * 1024;
-const MAX_READ_SCAN_BYTES = 16 * 1024 * 1024;
+import { optionalBool, requireString } from "./args.js";
+import { assertDirectWritableInRoot, displayPath, resolveDirectWritableInRoot, resolveExistingInRoot, } from "./paths.js";
+import { assertEditableText, assertReplacementFits, MAX_EDITABLE_CHARS, MAX_EDITABLE_LINES, readEditableText, } from "./text-boundary.js";
+import { count, plural } from "./file-summary.js";
 const DEFAULT_MUTATION_DEPENDENCIES = { atomicWrite };
-export const readFile = {
-    name: "read_file",
-    description: "Read a regular UTF-8 text file inside the workspace. Optionally start at a line " +
-        "(1-based) and cap how many lines come back. Large files are truncated.",
-    dangerous: false,
-    concurrency: "shared",
-    input: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "Path relative to the workspace root." },
-            offset: { type: "integer", description: "First line to return, 1-based." },
-            limit: { type: "integer", description: "How many lines to return." },
-        },
-        required: ["path"],
-    },
-    async run(args, ctx) {
-        return runReadFile(args, ctx);
-    },
-};
-export async function runReadFile(args, ctx, dependencies = {}) {
-    const root = await resolveExistingInRoot(ctx.root, ".");
-    const target = await resolveExistingInRoot(root, requireString(args, "path"));
-    const offset = optionalInt(args, "offset");
-    const limit = optionalInt(args, "limit");
-    const { text, truncated, scanCapped } = await readRange(root, target, offset, limit, ctx.signal, dependencies);
-    if (truncated) {
-        return {
-            output: `${text}\n\n[truncated at ${MAX_READ_CHARS} characters — read a narrower range]`,
-            summary: `truncated at ${MAX_READ_CHARS} characters`,
-        };
-    }
-    if (scanCapped) {
-        const notice = `[read stopped after scanning ${MAX_READ_SCAN_BYTES} bytes — use a smaller offset or search_text]`;
-        return {
-            output: text === "" ? notice : `${text}\n\n${notice}`,
-            summary: `scan capped at ${MAX_READ_SCAN_BYTES} bytes`,
-        };
-    }
-    if (text === "")
-        return { output: "[file is empty]", summary: "empty" };
-    return { output: text, summary: `${count(text, "line")}` };
-}
-export const listDir = {
-    name: "list_dir",
-    description: "List the entries of a directory inside the workspace. Directories end with a slash.",
-    dangerous: false,
-    concurrency: "shared",
-    input: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "Directory relative to the workspace root. Defaults to the root." },
-        },
-        required: [],
-    },
-    async run(args, ctx) {
-        return runListDir(args, ctx);
-    },
-};
-export async function runListDir(args, ctx, dependencies = {}) {
-    const root = await resolveExistingInRoot(ctx.root, ".");
-    const requested = optionalString(args, "path");
-    const relative = requested === undefined || requested.trim() === "" ? "." : requested;
-    const target = await resolveExistingInRoot(root, relative);
-    const inspected = await readStableDirectory(root, target, {
-        maxEntries: MAX_LIST_ENTRIES + 1,
-        signal: ctx.signal,
-        beforeOpen: dependencies.beforeOpen,
-    });
-    const entries = [];
-    let chars = 0;
-    let truncated = inspected.capped;
-    for (const entry of inspected.entries) {
-        const label = entry.kind === "directory" ? `${entry.name}/` : entry.name;
-        const separator = entries.length === 0 ? 0 : 1;
-        if (entries.length >= MAX_LIST_ENTRIES ||
-            chars + separator + label.length > MAX_LIST_CHARS) {
-            truncated = true;
-            break;
-        }
-        entries.push(label);
-        chars += separator + label.length;
-    }
-    if (entries.length === 0)
-        return { output: "[empty directory]", summary: "empty" };
-    const listing = entries.join("\n");
-    if (truncated) {
-        return {
-            output: `${listing}\n\n[truncated after ${entries.length} entries]`,
-            summary: `${entries.length}+ entries`,
-        };
-    }
-    return { output: listing, summary: plural(entries.length, "entry", "entries") };
-}
 export const writeFile = {
     name: "write_file",
     description: "Create a file, or replace its entire contents. Parent directories are " +
@@ -221,87 +122,6 @@ export async function runEditFile(args, ctx, dependencies = DEFAULT_MUTATION_DEP
         summary: plural(made, "replacement", "replacements"),
     };
 }
-async function readRange(root, target, offset, limit, signal, dependencies) {
-    throwIfAborted(signal);
-    const firstLine = Math.max(1, offset ?? 1);
-    const lineCount = limit === undefined ? undefined : Math.max(0, limit);
-    const endLine = lineCount === undefined ? Number.POSITIVE_INFINITY : firstLine + lineCount;
-    if (lineCount === 0)
-        return { text: "", truncated: false, scanCapped: false };
-    const result = await withStableFile(target, {
-        label: "read file",
-        signal,
-        beforeOpen: dependencies.beforeOpen,
-    }, async (handle, opened) => {
-        const decoder = new TextDecoder();
-        let text = "";
-        let line = 1;
-        let stopped = false;
-        let truncated = false;
-        let reachedEnd = false;
-        const selected = (at) => at >= firstLine && at < endLine;
-        const append = (fragment) => {
-            if (fragment === "")
-                return;
-            const room = MAX_READ_CHARS - text.length;
-            if (fragment.length > room) {
-                text += leadingText(fragment, room);
-                truncated = true;
-                stopped = true;
-                return;
-            }
-            text += fragment;
-        };
-        const consume = (chunk) => {
-            let start = 0;
-            while (!stopped && start < chunk.length) {
-                const newline = chunk.indexOf("\n", start);
-                const end = newline === -1 ? chunk.length : newline;
-                if (selected(line))
-                    append(chunk.slice(start, end));
-                if (stopped || newline === -1)
-                    return;
-                const nextLine = line + 1;
-                if (selected(line) && selected(nextLine))
-                    append("\n");
-                line = nextLine;
-                if (line >= endLine) {
-                    stopped = true;
-                    return;
-                }
-                start = newline + 1;
-            }
-        };
-        let position = 0;
-        const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
-        while (!stopped && position < MAX_READ_SCAN_BYTES) {
-            throwIfAborted(signal);
-            const length = Math.min(buffer.length, MAX_READ_SCAN_BYTES - position);
-            const { bytesRead } = await handle.read(buffer, 0, length, position);
-            throwIfAborted(signal);
-            if (bytesRead === 0) {
-                reachedEnd = true;
-                break;
-            }
-            position += bytesRead;
-            consume(decoder.decode(buffer.subarray(0, bytesRead), { stream: true }));
-        }
-        if (!stopped && BigInt(position) >= opened.size)
-            reachedEnd = true;
-        if (!stopped && reachedEnd)
-            consume(decoder.decode());
-        return {
-            text,
-            truncated,
-            scanCapped: !stopped && !reachedEnd && position >= MAX_READ_SCAN_BYTES,
-        };
-    });
-    const confirmed = await resolveExistingInRoot(root, target);
-    if (path.relative(target, confirmed) !== "") {
-        throw new Error("read file changed while it was being read");
-    }
-    return result;
-}
 function throwIfAborted(signal) {
     if (signal?.aborted !== true)
         return;
@@ -370,11 +190,3 @@ function changedFile(operation, previewed) {
     const when = previewed ? "after the preview" : "while preparing the change";
     return new Error(`file changed ${when} — inspect it and retry the ${operation}`);
 }
-function count(text, noun) {
-    if (text === "")
-        return "empty";
-    return plural(text.split("\n").length, noun, `${noun}s`);
-}
-function plural(n, one, many) {
-    return `${n} ${n === 1 ? one : many}`;
-}