@vietor/easy-agent 0.2.1 → 0.3.1

package/dist/core/session.js

@@ -1,75 +1,181 @@
-function estimateTokens(text) {
-    if (!text)
-        return 0;
-    const cjk = (text.match(/[一-龥぀-ヿ가-힯]/g) || []).length;
-    const words = (text.match(/[a-zA-Z0-9']+/g) || []).length;
-    return Math.ceil(cjk * 1.6 + words * 1.3 + (text.length - cjk) * 0.3);
-}
-function messageText(msg) {
-    const parts = [];
-    if (typeof msg.content === "string")
-        parts.push(msg.content);
-    else if (Array.isArray(msg.content)) {
-        for (const p of msg.content) {
-            if (p.type === "text")
-                parts.push(p.text);
+import { Agent } from "./agent.js";
+import { Conversation } from "./conversation.js";
+import { LogStore } from "./logstore.js";
+export class Session {
+    agent;
+    mcp;
+    commands;
+    log = new LogStore();
+    callbacks;
+    streamingText = "";
+    elapsed = 0;
+    abortController = null;
+    timer;
+    startTime = 0;
+    pendingQuestions = new Map();
+    questionSeq = 0;
+    getSnapshot = () => this.log.getSnapshot();
+    subscribe = (listener) => this.log.subscribe(listener);
+    get logEntries() {
+        return this.log.all;
+    }
+    constructor(llm, systemPrompt, tools, commands, mcp) {
+        const conversation = new Conversation(systemPrompt);
+        this.agent = new Agent(llm, conversation, tools, (q, o) => this.ask(q, o));
+        this.commands = commands;
+        this.mcp = mcp;
+        mcp.onError = (msg) => this.appendLog({ kind: "error", text: msg });
+        for (const msg of mcp.flushErrors())
+            this.appendLog({ kind: "error", text: msg });
+    }
+    dispose() {
+        this.mcp.kill();
+    }
+    setCallbacks(cb) {
+        this.callbacks = cb;
+    }
+    get contextTokens() {
+        return this.agent.contextTokens;
+    }
+    appendLog(entry) {
+        this.log.append(entry);
+    }
+    clearLog() {
+        this.log.clear();
+    }
+    clear() {
+        this.agent.clear();
+        this.clearLog();
+    }
+    export() {
+        return this.agent.export();
+    }
+    async compact() {
+        const ctrl = new AbortController();
+        this.abortController = ctrl;
+        try {
+            await this.agent.compact(ctrl.signal);
+            return true;
+        }
+        catch (e) {
+            if (ctrl.signal.aborted)
+                return false;
+            throw e;
+        }
+        finally {
+            this.abortController = null;
         }
     }
-    if ("tool_calls" in msg && msg.tool_calls) {
-        for (const tc of msg.tool_calls) {
-            if (tc.function?.name)
-                parts.push(tc.function.name);
-            if (tc.function?.arguments)
-                parts.push(tc.function.arguments);
+    abort() {
+        this.abortController?.abort();
+        for (const id of this.pendingQuestions.keys()) {
+            this.log.setAnswer(id, "");
+            this.pendingQuestions.get(id)?.("");
         }
+        this.pendingQuestions.clear();
     }
-    return parts.join(" ");
-}
-export class Session {
-    system;
-    messages = [];
-    estimatedTokens = 0;
-    checkpoint;
-    checkpointTokens = 0;
-    constructor(system) {
-        this.system = system;
-        this.messages.push({ role: "system", content: system });
-        this.estimatedTokens = estimateTokens(system);
-    }
-    getEstimatedTokens() {
-        return this.estimatedTokens;
-    }
-    add(msg) {
-        this.messages.push(msg);
-        this.estimatedTokens += estimateTokens(messageText(msg));
-    }
-    toLLM() {
-        return this.messages.map((m) => (m.role === "skill" ? { role: "user", name: m.name, content: m.content } : m));
+    ask(text, options) {
+        const id = `q${++this.questionSeq}`;
+        this.appendLog({ kind: "question", id, text, options, answer: null });
+        return new Promise((resolve) => {
+            this.pendingQuestions.set(id, resolve);
+        });
     }
-    export() {
-        return this.messages.slice(1);
+    submitAnswer(id, answer) {
+        this.log.setAnswer(id, answer);
+        const resolve = this.pendingQuestions.get(id);
+        if (resolve) {
+            this.pendingQuestions.delete(id);
+            resolve(answer);
+        }
     }
-    clear() {
-        this.messages = [{ role: "system", content: this.system }];
-        this.estimatedTokens = estimateTokens(this.system);
-    }
-    compact(summary) {
-        this.messages = [
-            { role: "system", content: this.system },
-            { role: "assistant", content: summary },
-        ];
-        this.estimatedTokens = estimateTokens(this.system) + estimateTokens(summary);
-    }
-    createCheckpoint() {
-        this.checkpoint = this.messages.slice();
-        this.checkpointTokens = this.estimatedTokens;
-    }
-    restoreCheckpoint() {
-        this.messages = this.checkpoint.slice();
-        this.estimatedTokens = this.checkpointTokens;
-    }
-    removeCheckpoint() {
-        this.checkpoint = undefined;
-        this.checkpointTokens = 0;
+    get commandSchemas() {
+        return this.commands.schemas();
+    }
+    isCommand(name) {
+        return this.commands.exists(name);
+    }
+    async executeCommand(name, host) {
+        await this.commands.execute(name, { session: this, mcp: this.mcp }, {
+            exit: host.exit,
+            info: (t) => this.appendLog({ kind: "system", text: t }),
+            error: (t) => this.appendLog({ kind: "error", text: t }),
+            thinking: (on) => host.setRunning(on),
+            runSkill: (s) => this.startSkill(s),
+        });
+    }
+    async startPrompt(text) {
+        this.appendLog({ kind: "user", text });
+        await this.run((signal) => this.agent.run(text, this.makeHandler(), signal));
+    }
+    async startSkill(skill) {
+        this.appendLog({ kind: "skill", name: skill.name });
+        await this.run((signal) => this.agent.runSkill(skill, this.makeHandler(), signal));
+    }
+    async run(runFn) {
+        this.streamingText = "";
+        this.elapsed = 0;
+        this.startTime = Date.now();
+        this.abortController = new AbortController();
+        this.callbacks?.onElapsedChange?.(0);
+        this.callbacks?.onUsageChange?.(0, 0);
+        this.callbacks?.onRunStateChange?.(true);
+        this.timer = setInterval(() => {
+            this.elapsed = Math.floor((Date.now() - this.startTime) / 1000);
+            this.callbacks?.onElapsedChange?.(this.elapsed);
+        }, 1000);
+        try {
+            await runFn(this.abortController.signal);
+            this.flushStreaming();
+        }
+        catch (e) {
+            this.flushStreaming();
+            this.appendLog({ kind: "error", text: e.message });
+        }
+        finally {
+            clearInterval(this.timer);
+            this.timer = undefined;
+            this.abortController = null;
+            this.callbacks?.onRunStateChange?.(false);
+        }
+    }
+    makeHandler() {
+        return (e) => {
+            switch (e.type) {
+                case "delta":
+                    this.streamingText += e.text;
+                    this.callbacks?.onStreaming?.(this.streamingText);
+                    break;
+                case "tool_start":
+                    this.flushStreaming();
+                    this.appendLog({ kind: "tool", id: e.id, name: e.name, summary: e.summary, result: null });
+                    break;
+                case "retry":
+                    this.streamingText = "";
+                    this.appendLog({ kind: "retry", attempt: e.attempt, max: e.max });
+                    break;
+                case "tool_end":
+                    this.log.setResult(e.id, e.result, e.isError);
+                    break;
+                case "error":
+                    this.flushStreaming();
+                    this.appendLog({ kind: "error", text: e.text });
+                    break;
+                case "interrupted":
+                    this.flushStreaming();
+                    this.appendLog({ kind: "interrupted" });
+                    break;
+                case "usage":
+                    this.callbacks?.onUsageChange?.(e.promptTokens, e.completionTokens);
+                    break;
+            }
+        };
+    }
+    flushStreaming() {
+        if (this.streamingText) {
+            this.appendLog({ kind: "assistant", text: this.streamingText });
+            this.streamingText = "";
+            this.callbacks?.onStreaming?.("");
+        }
     }
 }

package/dist/llm/client.js

@@ -1,4 +1,4 @@
-import OpenAI, { APIConnectionError } from "openai";
+import OpenAI, { APIConnectionError, APIError } from "openai";
 import { withRetry } from "../util/async.js";
 const MAX_RETRIES = 3;
 export class LLMClient {
@@ -12,13 +12,19 @@ export class LLMClient {
         });
         this.model = config.model;
     }
-    async chat(messages, tools, onDelta, onRetry, onUsage, signal) {
-        return withRetry(() => this.streamOnce(messages, tools, onDelta, onUsage, signal), {
+    async chat(opts) {
+        return withRetry(() => this.streamOnce(opts.messages, opts.tools, opts.onDelta, opts.onUsage, opts.signal), {
             retries: MAX_RETRIES,
-            retryable: (e) => e instanceof APIConnectionError,
+            retryable: (e) => {
+                if (e instanceof APIConnectionError)
+                    return true;
+                if (e instanceof APIError && e.status)
+                    return e.status === 429 || e.status >= 500;
+                return false;
+            },
             backoff: (attempt) => 1000 * 2 ** attempt,
-            onRetry,
-            signal,
+            onRetry: opts.onRetry,
+            signal: opts.signal,
         });
     }
     async streamOnce(messages, tools, onDelta, onUsage, signal) {

package/dist/main.js

@@ -3,27 +3,32 @@ import { join } from "node:path";
 import { loadConfig } from "./config.js";
 import { LLMClient } from "./llm/client.js";
 import { Session } from "./core/session.js";
-import { Agent } from "./core/agent.js";
 import { ToolRegistry, registerBuiltinTools } from "./tools/registry.js";
 import { CommandRegistry, registerBuiltinCommands } from "./cmds/registry.js";
 import { tryLoadSkills } from "./skills/loader.js";
 import { tryReadFileText, readFirstFileContent } from "./util/fs.js";
 import { MCPServers } from "./mcp/server.js";
 import { startApp } from "./tui/App.js";
-const SYSTEM_PROMPT_BASE = `You are Easy Agent, an autonomous coding assistant running in the terminal. You complete tasks by calling tools, inspecting their results, and iterating until the work is done.
-
-Environment:
-- Platform: ${process.platform}
-- Working directory: ${process.cwd()}
-
-Tool use:
-- Prefer dedicated tools (FileRead, FileEdit, Glob, Grep) over the Shell tool when they fit the task.
-- Read a file before editing it; make minimal, surgical changes that match the surrounding code style.
-- Reference code as file_path:line_number.
-
-Output:
-- Be concise and use GitHub-flavored markdown.
-- State what you did and stop once the task is complete. Report outcomes faithfully, and do not narrate alternatives you will not pursue.`;
+const SYSTEM_PROMPT_BASE = [
+    "You are Easy Agent, an autonomous coding assistant running in the terminal. You complete tasks by calling tools, inspecting their results, and iterating until the work is done.",
+    `Environment:
+- Platform: ${process.platform}
+- Working directory: ${process.cwd()}`,
+    [
+        "Tool use:",
+        "- Prefer dedicated tools (FileRead, FileWrite, FileEdit, Glob, Grep, WebFetch) over the Shell tool when they fit the task.",
+        "- Read a file before editing it; make minimal, surgical changes that match the surrounding code style.",
+        "- Reference code as file_path:line_number.",
+        "- When a decision belongs to the user, call AskUser and wait for the answer rather than listing options in prose. Ask when there are multiple reasonable approaches, an irreversible or consequential action, or the request is ambiguous; when you have enough to proceed, act without asking.",
+        ...(process.platform === "linux"
+            ? ["- For privileged shell commands, use `sudo -n` (non-interactive); if it reports a password is required, do not retry - surface the command for the user to run manually."]
+            : []),
+    ].join("\n"),
+    `Output:
+- Be concise and use GitHub-flavored markdown.
+- State what you did and stop once the task is complete; report outcomes faithfully.
+- Do not lay out alternative approaches in prose - if a choice is the user's, use AskUser.`,
+].join("\n\n");
 export async function main() {
     const config = loadConfig();
     const llm = new LLMClient(config.llm);
@@ -31,13 +36,9 @@ export async function main() {
     registerBuiltinTools(tools);
     const commands = new CommandRegistry();
     registerBuiltinCommands(commands);
-    const mcp = new MCPServers();
+    const mcp = new MCPServers(tools);
     mcp
         .connect(config.mcpServers)
-        .then((list) => {
-        for (const t of list)
-            tools.register(t);
-    })
         .catch((e) => mcp.report(`MCP connect failed: ${e.message}`));
     const globalSkills = readFirstFileContent([join(homedir(), ".agents", "skills"), join(homedir(), ".claude", "skills")], tryLoadSkills);
     if (globalSkills) {
@@ -54,8 +55,7 @@ export async function main() {
     const systemPrompt = [SYSTEM_PROMPT_BASE, globalPrompt, projectPrompt]
         .filter(Boolean)
         .join("\n\n=================\n\n");
-    const session = new Session(systemPrompt);
-    const agent = new Agent(llm, session, tools);
-    const app = startApp(agent, commands, mcp);
-    await app.waitUntilExit().finally(() => mcp.kill());
+    const session = new Session(llm, systemPrompt, tools, commands, mcp);
+    const app = startApp(session);
+    await app.waitUntilExit().finally(() => session.dispose());
 }

package/dist/mcp/client.js

@@ -1,18 +1,46 @@
+import { spawnSync } from "node:child_process";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { getPackageInfo } from "../util/package.js";
-function getClientINfo() {
+function getClientInfo() {
     const pkginfo = getPackageInfo();
     return { name: pkginfo.name, version: pkginfo.version };
 }
+const STDERR_MAX_LINES = 20;
 export class MCPClient {
     name;
-    client = new Client(getClientINfo(), { capabilities: {} });
+    client = new Client(getClientInfo(), { capabilities: {} });
     transport;
     connectReject;
+    stderrBuf = [];
     constructor(name, config) {
         this.name = name;
-        this.transport = new StdioClientTransport({ ...config, stderr: "ignore" });
+        if ("command" in config) {
+            const t = new StdioClientTransport({ ...config, stderr: "pipe" });
+            this.transport = t;
+            t.stderr?.on("data", (chunk) => {
+                for (const line of chunk.toString("utf8").split(/\r?\n/)) {
+                    if (!line)
+                        continue;
+                    this.stderrBuf.push(line);
+                    if (this.stderrBuf.length > STDERR_MAX_LINES)
+                        this.stderrBuf.shift();
+                }
+            });
+        }
+        else {
+            const opts = { requestInit: { headers: config.headers } };
+            const url = new URL(config.url);
+            this.transport =
+                config.type === "sse"
+                    ? new SSEClientTransport(url, opts)
+                    : new StreamableHTTPClientTransport(url, opts);
+        }
+    }
+    stderrTail() {
+        return this.stderrBuf.join("\n");
     }
     async connect() {
         return new Promise((resolve, reject) => {
@@ -28,16 +56,24 @@ export class MCPClient {
     async listTools() {
         return this.client.listTools().then((r) => r.tools);
     }
-    async callTool(name, args) {
-        return this.client.callTool({ name, arguments: args });
+    async callTool(name, args, signal) {
+        return this.client.callTool({ name, arguments: args }, undefined, { signal });
     }
     kill() {
         this.connectReject?.(new Error("aborted"));
         this.connectReject = undefined;
-        const pid = this.transport.pid;
-        if (pid) {
+        this.client.close().catch(() => { });
+        if (this.transport instanceof StdioClientTransport) {
+            const pid = this.transport.pid;
+            if (!pid)
+                return;
             try {
-                process.kill(pid, "SIGTERM");
+                if (process.platform === "win32") {
+                    spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true });
+                }
+                else {
+                    process.kill(pid, "SIGTERM");
+                }
             }
             catch { }
         }

package/dist/mcp/server.js

@@ -1,15 +1,49 @@
 import { MCPClient } from "./client.js";
 import { withTimeout } from "../util/async.js";
 const CONNECT_TIMEOUT = 30_000;
+function serverType(cfg) {
+    return "command" in cfg ? "stdio" : cfg.type;
+}
 function fixError(text) {
     return text.startsWith("Error: ") ? text : `Error: ${text}`;
 }
+function extractContent(result) {
+    const parts = [];
+    for (const c of result.content) {
+        switch (c.type) {
+            case "text":
+                parts.push(c.text);
+                break;
+            case "image":
+                parts.push(`[image: ${c.mimeType}]`);
+                break;
+            case "audio":
+                parts.push(`[audio: ${c.mimeType}]`);
+                break;
+            case "resource": {
+                const r = c.resource;
+                parts.push("text" in r ? r.text : `[resource: ${r.uri}]`);
+                break;
+            }
+            default:
+                parts.push(`[${c.type}]`);
+        }
+    }
+    if (result.structuredContent) {
+        parts.push(`<structured>${JSON.stringify(result.structuredContent)}</structured>`);
+    }
+    return parts.join("\n");
+}
 export class MCPServers {
+    tools;
     servers = new Map();
     pending = new Set();
     disposed = false;
     errorBuffer = [];
     onError;
+    constructor(tools) {
+        this.tools = tools;
+    }
     report(msg) {
         if (this.onError)
             this.onError(msg);
@@ -22,10 +56,15 @@ export class MCPServers {
         return buf;
     }
     async connect(mcpServers = {}) {
-        const tools = [];
         await Promise.all(Object.entries(mcpServers).map(async ([name, cfg]) => {
             if (this.disposed)
                 return;
+            const type = serverType(cfg);
+            if (cfg.enabled === false) {
+                this.servers.set(name, { type, status: "disabled", tools: [] });
+                return;
+            }
+            this.servers.set(name, { type, status: "pending", tools: [] });
             const client = new MCPClient(name, cfg);
             this.pending.add(client);
             try {
@@ -39,31 +78,31 @@ export class MCPServers {
                     client.kill();
                     return;
                 }
-                this.servers.set(name, { status: "connected", client, tools: mcpTools.map((t) => t.name) });
+                this.servers.set(name, { type, status: "online", client, tools: mcpTools.map((t) => t.name) });
                 for (const t of mcpTools)
-                    tools.push(this.adapt(name, client, t));
+                    this.tools.register(this.adapt(name, client, t));
             }
             catch (e) {
                 client.kill();
                 if (!this.disposed) {
-                    this.servers.set(name, { status: "disabled", tools: [] });
-                    this.report(`MCP server "${name}" failed: ${e.message}`);
+                    this.servers.set(name, { type, status: "offline", tools: [] });
+                    const stderr = client.stderrTail();
+                    this.report(`MCP server "${name}" failed: ${e.message}${stderr ? `\n${stderr}` : ""}`);
                 }
             }
             finally {
                 this.pending.delete(client);
             }
         }));
-        return tools;
     }
     adapt(server, client, tool) {
         return {
             name: `MCP__${server}__${tool.name}`,
             description: tool.description ?? `${server} ${tool.name}`,
             parameters: tool.inputSchema,
-            async execute(args) {
-                const result = await client.callTool(tool.name, args);
-                const text = result.content.map((c) => (c.type === "text" ? c.text : "")).join("\n");
+            async execute(args, ctx) {
+                const result = await client.callTool(tool.name, args, ctx.signal);
+                const text = extractContent(result);
                 return result.isError
                     ? { content: fixError(text), isError: true }
                     : { content: text || "(no output)" };
@@ -71,7 +110,7 @@ export class MCPServers {
         };
     }
     list() {
-        return [...this.servers.entries()].map(([name, s]) => ({ name, status: s.status, tools: s.tools }));
+        return [...this.servers.entries()].map(([name, s]) => ({ name, type: s.type, status: s.status, tools: s.tools }));
     }
     kill() {
         this.disposed = true;

package/dist/tools/ask_user.js

@@ -0,0 +1,24 @@
+const DESCRIPTION = [
+    "Ask the user a question and wait for their answer.",
+    "Use when a decision belongs to the user: multiple reasonable approaches, an irreversible or consequential action, or an ambiguous request. Present choices via options rather than prose.",
+    "options is an optional list of choices; the user may also type a custom answer.",
+    "Returns the user's answer as text; an empty string means the user skipped the question.",
+].join(" ");
+export const askUserTool = {
+    name: "AskUser",
+    description: DESCRIPTION,
+    parameters: {
+        type: "object",
+        properties: {
+            question: { type: "string", description: "The question to ask the user." },
+            options: { type: "array", items: { type: "string" }, description: "Optional list of choices." },
+        },
+        required: ["question"],
+    },
+    async execute(args, ctx) {
+        const question = args.question;
+        const options = Array.isArray(args.options) ? args.options : [];
+        return ctx.ask(question, options);
+    },
+    summaryArg: "question",
+};

package/dist/tools/file_edit.js

@@ -1,7 +1,9 @@
 import { readFile, writeFile } from "node:fs/promises";
 const DESCRIPTION = [
-    "Replace the single occurrence of old_string with new_string in a file.",
-    "old_string must match exactly (including whitespace and indentation) and appear exactly once; read the file first and include enough surrounding context to be unique.",
+    "Replace occurrences of old_string with new_string in a file.",
+    "old_string must match exactly (including whitespace and indentation); read the file first and include enough surrounding context to be unique.",
+    "By default old_string must appear exactly once; set replace_all to true to replace every occurrence.",
+    "When copying old_string from FileRead output, strip the leading line-number prefix (digits and tab) before matching.",
     "For full rewrites prefer FileWrite.",
 ].join(" ");
 export const fileEditTool = {
@@ -13,6 +15,7 @@ export const fileEditTool = {
             path: { type: "string" },
             old_string: { type: "string" },
             new_string: { type: "string" },
+            replace_all: { type: "boolean", description: "replace all occurrences (default false)" },
         },
         required: ["path", "old_string", "new_string"],
     },
@@ -20,6 +23,7 @@ export const fileEditTool = {
         const path = args.path;
         const oldStr = args.old_string;
         const newStr = args.new_string;
+        const all = args.replace_all === true;
         if (!path)
             throw new Error("path is required");
         if (!oldStr)
@@ -27,11 +31,15 @@ export const fileEditTool = {
         if (newStr === undefined)
             throw new Error("new_string is required");
         const content = await readFile(path, "utf-8");
-        const count = content.split(oldStr).length - 1;
-        if (count === 0)
+        if (!content.includes(oldStr))
             throw new Error(`old_string not found in ${path}`);
+        if (all) {
+            await writeFile(path, content.split(oldStr).join(newStr), "utf-8");
+            return `Edited ${path} (replaced all)`;
+        }
+        const count = content.split(oldStr).length - 1;
         if (count > 1)
-            throw new Error(`old_string appears ${count} times in ${path}, must be unique`);
+            throw new Error(`old_string appears ${count} times in ${path}, must be unique (or set replace_all)`);
         await writeFile(path, content.replace(oldStr, newStr), "utf-8");
         return `Edited ${path}`;
     },

package/dist/tools/file_read.js

@@ -1,18 +1,43 @@
 import { readFile } from "node:fs/promises";
+const DEFAULT_LIMIT = 2000;
 const DESCRIPTION = [
-    "Read a file's full contents as UTF-8 text.",
+    "Read a file's contents as UTF-8 text, returned with line numbers (cat -n format).",
     "path may be relative (to the working directory) or absolute.",
+    "Reads up to 2000 lines by default; use offset and limit to page through larger files.",
 ].join(" ");
 export const fileReadTool = {
     name: "FileRead",
     description: DESCRIPTION,
     parameters: {
         type: "object",
-        properties: { path: { type: "string" } },
+        properties: {
+            path: { type: "string" },
+            offset: { type: "number", description: "line number to start reading from (1-indexed)" },
+            limit: { type: "number", description: "number of lines to read (default 2000)" },
+        },
         required: ["path"],
     },
     async execute(args) {
-        return readFile(args.path, "utf-8");
+        const path = args.path;
+        const offset = args.offset || 1;
+        const limit = args.limit || DEFAULT_LIMIT;
+        const content = await readFile(path, "utf-8");
+        if (!content)
+            return "(empty file)";
+        const lines = content.split("\n");
+        const start = Math.max(0, offset - 1);
+        if (start >= lines.length) {
+            return `(offset ${offset} is past end of file; file has ${lines.length} lines)`;
+        }
+        const end = Math.min(lines.length, start + limit);
+        const slice = lines.slice(start, end);
+        let out = slice
+            .map((line, i) => `${String(start + i + 1).padStart(6, " ")}\t${line}`)
+            .join("\n");
+        if (end < lines.length) {
+            out += `\n(${lines.length - end} more lines; use offset=${end + 1} to continue)`;
+        }
+        return out;
     },
     summaryArg: "path",
 };