smolcoder 0.4.0

package/dist/tools/index.js

@@ -0,0 +1,236 @@
+"use strict";
+// Tool registry. Seven tools, flat parameters only (strings and one enum — no
+// nested objects or arrays: small models mangle them), an example call inside
+// every description (small models imitate better than they infer), and the
+// mode decides which tools EXIST — the permission model is "which schemas were
+// sent", not a runtime policy engine.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODE_LABELS = void 0;
+exports.buildToolSpecs = buildToolSpecs;
+exports.executeTool = executeTool;
+exports.commandOf = commandOf;
+const fs_tools_1 = require("./fs-tools");
+const check_1 = require("./check");
+const shell_1 = require("./shell");
+const sandbox_1 = require("../sandbox");
+const util_1 = require("../util");
+exports.MODE_LABELS = {
+    ro: "read-only",
+    edit: "edit",
+    bypass: "bypass permissions",
+};
+const TOOL_RESULT_CAP = 10000; // chars — final safety net over per-tool caps
+function buildToolSpecs(mode) {
+    const read = [
+        {
+            name: "read_file",
+            description: 'Read a text file in the workspace. Example: {"path": "src/app.js"}. Long files are returned in chunks; pass "offset" (a line number) to continue reading.',
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path relative to the workspace" },
+                    offset: { type: "number", description: "Line number to start from (optional)" },
+                    limit: { type: "number", description: "Max lines to return (optional)" },
+                },
+                required: ["path"],
+            },
+        },
+        {
+            name: "list_files",
+            description: 'List files and folders in the workspace. Example: {} for everything, or {"path": "src"} for one folder. Folders end with "/".',
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Folder to list (optional, default: whole workspace)" },
+                },
+            },
+        },
+        {
+            name: "search",
+            description: 'Search inside files for a pattern (regular expression; plain text also works). Example: {"pattern": "TODO"}. Returns file:line: matching text.',
+            parameters: {
+                type: "object",
+                properties: {
+                    pattern: { type: "string", description: "Text or regex to find" },
+                    path: { type: "string", description: "Folder to search in (optional)" },
+                },
+                required: ["pattern"],
+            },
+        },
+        {
+            name: "plan",
+            description: 'Your to-do list for multi-step tasks — shown to the user and kept for you across context compaction. Create it first: {"action": "set", "steps": "create index.html\\ncreate game.js\\ntest the page"} (one step per line). Mark the current step finished with {"action": "done"} (or {"action": "done", "step": 2}). Append with {"action": "add", "text": "..."}. {"action": "show"} displays it.',
+            parameters: {
+                type: "object",
+                properties: {
+                    action: { type: "string", enum: ["set", "done", "add", "show"] },
+                    steps: { type: "string", description: 'The steps, one per line (only for "set")' },
+                    step: { type: "number", description: 'Step number to mark done (optional, for "done")' },
+                    text: { type: "string", description: 'Step to append (only for "add")' },
+                },
+                required: ["action"],
+            },
+        },
+    ];
+    const write = [
+        {
+            name: "write_file",
+            description: 'Create a new file or completely overwrite an existing one. Example: {"path": "src/new.js", "content": "..."}. Parent folders are created automatically. To change part of an existing file, prefer edit_file.',
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path relative to the workspace" },
+                    content: { type: "string", description: "The full file content" },
+                },
+                required: ["path", "content"],
+            },
+        },
+        {
+            name: "edit_file",
+            description: 'Replace text inside an existing file. Copy old_text EXACTLY from the file (a few lines, enough to be unique), and give the replacement as new_text. Example: {"path": "src/app.js", "old_text": "const x = 1;", "new_text": "const x = 2;"}',
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path relative to the workspace" },
+                    old_text: { type: "string", description: "Exact text currently in the file" },
+                    new_text: { type: "string", description: "Text to replace it with" },
+                },
+                required: ["path", "old_text", "new_text"],
+            },
+        },
+    ];
+    const exec = [
+        {
+            name: "run_command",
+            description: 'Run a shell command in the workspace and wait for it to finish. Example: {"command": "npm test"}. Times out after 120s — for servers or watchers use the task tool instead.',
+            parameters: {
+                type: "object",
+                properties: {
+                    command: { type: "string", description: "The command to run" },
+                },
+                required: ["command"],
+            },
+        },
+        {
+            name: "task",
+            description: 'Manage background tasks (things that keep running, like dev servers). action "start" runs a command in the background: {"action": "start", "command": "npm run dev"}. action "logs" shows recent output: {"action": "logs", "task_id": "t1"}. action "list" shows all tasks. action "stop" kills one: {"action": "stop", "task_id": "t1"}.',
+            parameters: {
+                type: "object",
+                properties: {
+                    action: { type: "string", enum: ["start", "list", "logs", "stop"] },
+                    command: { type: "string", description: 'Command to run (only for "start")' },
+                    task_id: { type: "string", description: 'Task id like "t1" (for "logs" and "stop")' },
+                },
+                required: ["action"],
+            },
+        },
+    ];
+    if (mode === "ro")
+        return read;
+    return [...read, ...write, ...exec];
+}
+async function executeTool(name, args, ctx, signal) {
+    try {
+        let result;
+        switch (name) {
+            case "read_file":
+                result = (0, fs_tools_1.readFile)(ctx.workspace, args);
+                break;
+            case "list_files":
+                result = (0, fs_tools_1.listFiles)(ctx.workspace, args);
+                break;
+            case "search":
+                result = (0, fs_tools_1.searchFiles)(ctx.workspace, args);
+                break;
+            case "plan": {
+                const action = args.action;
+                if (action === "set")
+                    result = ctx.plan.set(String(args.steps ?? ""));
+                else if (action === "done")
+                    result = ctx.plan.markDone(args.step === undefined ? undefined : Number(args.step));
+                else if (action === "add")
+                    result = ctx.plan.add(String(args.text ?? ""));
+                else if (action === "show")
+                    result = ctx.plan.modelView();
+                else
+                    return 'Error: action must be one of "set", "done", "add", "show". Example: {"action": "done"}';
+                break;
+            }
+            case "write_file":
+                result = (0, fs_tools_1.writeFile)(ctx.workspace, args);
+                if (!result.startsWith("Error")) {
+                    ctx.filesTouched.add(String(args.path));
+                    result += afterWrite(ctx.workspace, String(args.path));
+                }
+                break;
+            case "edit_file":
+                result = (0, fs_tools_1.editFile)(ctx.workspace, args);
+                if (!result.startsWith("Error")) {
+                    ctx.filesTouched.add(String(args.path));
+                    result += afterWrite(ctx.workspace, String(args.path));
+                }
+                break;
+            case "run_command":
+                if (typeof args.command !== "string" || !args.command.trim()) {
+                    return 'Error: command is required. Example: {"command": "npm test"}';
+                }
+                ctx.commandsRun.push(args.command);
+                result = await (0, shell_1.runCommand)(args.command, ctx.workspace, signal);
+                break;
+            case "task": {
+                const action = args.action;
+                if (action === "start") {
+                    if (typeof args.command !== "string" || !args.command.trim()) {
+                        return 'Error: "start" needs a command. Example: {"action": "start", "command": "npm run dev"}';
+                    }
+                    ctx.commandsRun.push(`[bg] ${args.command}`);
+                    result = await ctx.taskManager.startWithEarlyOutput(args.command);
+                }
+                else if (action === "logs") {
+                    result = ctx.taskManager.logs(String(args.task_id ?? ""), Number(args.lines) || 50);
+                }
+                else if (action === "stop") {
+                    result = ctx.taskManager.stop(String(args.task_id ?? ""));
+                }
+                else if (action === "list") {
+                    result = ctx.taskManager.list();
+                }
+                else {
+                    return 'Error: action must be one of "start", "list", "logs", "stop". Example: {"action": "list"}';
+                }
+                break;
+            }
+            default:
+                return `Error: unknown tool "${name}". Available tools are listed in your tool definitions — use one of those.`;
+        }
+        return (0, util_1.truncateMiddle)(result, TOOL_RESULT_CAP);
+    }
+    catch (err) {
+        if (err instanceof sandbox_1.SandboxError)
+            return `Error: ${err.message}`;
+        return `Error: ${err?.message ?? String(err)}`;
+    }
+}
+/** Post-write hook: parse what was just written and coach on the first
+ * syntax error. A one-line warning riding on the success message is the
+ * cheapest possible feedback loop for a local model. */
+function afterWrite(workspace, relPath) {
+    try {
+        const abs = (0, sandbox_1.resolveInWorkspace)(workspace, relPath);
+        const warning = (0, check_1.syntaxCheck)(abs, relPath);
+        return warning ? `
+Warning: ${warning} Fix this before moving on (use edit_file).` : "";
+    }
+    catch {
+        return "";
+    }
+}
+/** The command a call would run, if it is an exec call (edit mode may gate it;
+ * bypass never asks; in ro mode the tool does not exist). */
+function commandOf(name, args) {
+    if (name === "run_command")
+        return String(args.command ?? "");
+    if (name === "task" && args.action === "start")
+        return String(args.command ?? "");
+    return null;
+}

package/dist/tools/shell.js

@@ -0,0 +1,168 @@
+"use strict";
+// run_command: one-shot foreground commands, cwd-locked to the workspace.
+// Shell picking matters on Windows: local models emit POSIX commands, so we
+// prefer Git Bash when it exists, skip WSL's System32 bash (different
+// filesystem world), and fall back to PowerShell. The chosen shell is named in
+// the system prompt so the model knows what dialect to write.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickShell = pickShell;
+exports.killTree = killTree;
+exports.runCommand = runCommand;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util_1 = require("../util");
+let cached = null;
+function pickShell() {
+    if (cached)
+        return cached;
+    if (process.platform === "win32") {
+        const candidates = [
+            path.join(process.env["ProgramFiles"] ?? "C:\\Program Files", "Git", "bin", "bash.exe"),
+            path.join(process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)", "Git", "bin", "bash.exe"),
+            path.join(process.env["LOCALAPPDATA"] ?? "", "Programs", "Git", "bin", "bash.exe"),
+        ];
+        for (const p of candidates) {
+            if (p && fs.existsSync(p)) {
+                cached = { exe: p, argsFor: (cmd) => ["-lc", cmd], label: "bash (Git Bash)" };
+                return cached;
+            }
+        }
+        // any bash on PATH that is not WSL's System32 shim
+        const where = (0, child_process_1.spawnSync)("where.exe", ["bash"], { encoding: "utf8" });
+        if (where.status === 0) {
+            const found = where.stdout
+                .split(/\r?\n/)
+                .map((s) => s.trim())
+                .find((p) => p && !p.toLowerCase().includes("system32"));
+            if (found) {
+                cached = { exe: found, argsFor: (cmd) => ["-lc", cmd], label: "bash (Git Bash)" };
+                return cached;
+            }
+        }
+        cached = {
+            exe: "powershell.exe",
+            argsFor: (cmd) => ["-NoProfile", "-NonInteractive", "-Command", cmd],
+            label: "PowerShell",
+        };
+        return cached;
+    }
+    const sh = fs.existsSync("/bin/bash") ? "/bin/bash" : "/bin/sh";
+    cached = { exe: sh, argsFor: (cmd) => ["-lc", cmd], label: path.basename(sh) };
+    return cached;
+}
+function killTree(pid) {
+    try {
+        if (process.platform === "win32") {
+            (0, child_process_1.spawnSync)("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore" });
+        }
+        else {
+            process.kill(-pid, "SIGKILL");
+        }
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            /* already gone */
+        }
+    }
+}
+const OUTPUT_CAP = 8000;
+const DEFAULT_TIMEOUT_MS = 120_000;
+function runCommand(command, cwd, signal) {
+    return new Promise((resolve) => {
+        const shell = pickShell();
+        let output = "";
+        let finished = false;
+        const started = Date.now();
+        const proc = (0, child_process_1.spawn)(shell.exe, shell.argsFor(command), {
+            cwd,
+            env: process.env,
+            detached: process.platform !== "win32", // process group for killTree
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const append = (chunk) => {
+            if (output.length < OUTPUT_CAP * 4)
+                output += chunk.toString("utf8");
+        };
+        proc.stdout.on("data", append);
+        proc.stderr.on("data", append);
+        // User interrupt (esc / ctrl+c / web stop button): kill the whole tree now.
+        const onAbort = () => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            killTree(proc.pid);
+            resolve((output.trim() ? (0, util_1.truncateMiddle)(output, OUTPUT_CAP) + "\n" : "") +
+                "[command cancelled by the user before it finished]");
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        const cleanup = () => signal?.removeEventListener("abort", onAbort);
+        const timer = setTimeout(() => {
+            if (finished)
+                return;
+            finished = true;
+            cleanup();
+            killTree(proc.pid);
+            resolve((0, util_1.truncateMiddle)(output, OUTPUT_CAP) +
+                `\n[command timed out after ${DEFAULT_TIMEOUT_MS / 1000}s and was killed. For long-running commands like dev servers, use the task tool with {"action": "start"} instead.]`);
+        }, DEFAULT_TIMEOUT_MS);
+        proc.on("error", (err) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            cleanup();
+            resolve(`Error: could not start command: ${err.message}`);
+        });
+        proc.on("close", (code) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            cleanup();
+            const secs = ((Date.now() - started) / 1000).toFixed(1);
+            const body = output.trim() ? (0, util_1.truncateMiddle)(output, OUTPUT_CAP) : "(no output)";
+            resolve(`${body}\n[exit code ${code ?? "?"} in ${secs}s]`);
+        });
+        if (signal?.aborted)
+            onAbort();
+    });
+}

package/dist/tools/tasks.js

@@ -0,0 +1,128 @@
+"use strict";
+// Background tasks: one `task` tool with an action enum instead of four
+// separate tools — one schema costs fewer context tokens, and small models
+// handle enum dispatch on a single tool fine. Each task keeps a ring buffer of
+// recent output so the agent (and the user, via /tasks and /logs) has
+// visibility. All tasks are killed when smolcoder exits.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManager = void 0;
+const child_process_1 = require("child_process");
+const shell_1 = require("./shell");
+const RING_SIZE = 300;
+class TaskManager {
+    cwd;
+    tasks = new Map();
+    counter = 0;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    start(command) {
+        const shell = (0, shell_1.pickShell)();
+        const id = `t${++this.counter}`;
+        const proc = (0, child_process_1.spawn)(shell.exe, shell.argsFor(command), {
+            cwd: this.cwd,
+            env: process.env,
+            detached: process.platform !== "win32",
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const task = {
+            id,
+            command,
+            proc,
+            lines: [],
+            status: "running",
+            exitCode: null,
+            startedAt: Date.now(),
+        };
+        const push = (chunk) => {
+            for (const line of chunk.toString("utf8").split(/\r?\n/)) {
+                if (line === "")
+                    continue;
+                task.lines.push(line);
+                if (task.lines.length > RING_SIZE)
+                    task.lines.shift();
+            }
+        };
+        proc.stdout?.on("data", push);
+        proc.stderr?.on("data", push);
+        proc.on("error", (err) => {
+            task.lines.push(`[failed to start: ${err.message}]`);
+            task.status = "exited";
+            task.exitCode = -1;
+        });
+        proc.on("close", (code) => {
+            if (task.status === "running") {
+                task.status = "exited";
+                task.exitCode = code;
+            }
+        });
+        this.tasks.set(id, task);
+        return id;
+    }
+    /** Wait briefly after start so early output (or an instant crash) is visible. */
+    async startWithEarlyOutput(command) {
+        const id = this.start(command);
+        await new Promise((r) => setTimeout(r, 1500));
+        const task = this.tasks.get(id);
+        const early = task.lines.slice(-15).join("\n");
+        const status = task.status === "running"
+            ? `Task ${id} is running in the background.`
+            : `Task ${id} exited almost immediately (exit code ${task.exitCode}).`;
+        return `${status} Command: ${command}\n${early ? `Early output:\n${early}\n` : ""}Use task {"action": "logs", "task_id": "${id}"} to check on it, {"action": "stop"} to kill it.`;
+    }
+    logs(taskId, lineCount = 50) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return this.unknownTask(taskId);
+        const tail = task.lines.slice(-Math.min(Math.max(lineCount, 1), RING_SIZE));
+        const header = `Task ${task.id} [${task.status}${task.exitCode !== null ? ` code ${task.exitCode}` : ""}] ${task.command}`;
+        return `${header}\n${tail.length ? tail.join("\n") : "(no output yet)"}`;
+    }
+    stop(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return this.unknownTask(taskId);
+        if (task.status !== "running")
+            return `Task ${taskId} already ${task.status}.`;
+        task.status = "stopped";
+        (0, shell_1.killTree)(task.proc.pid);
+        return `Task ${taskId} stopped. (${task.command})`;
+    }
+    list() {
+        if (this.tasks.size === 0)
+            return "No background tasks. Start one with task {\"action\": \"start\", \"command\": \"...\"}.";
+        const rows = [...this.tasks.values()].map((t) => {
+            const age = Math.round((Date.now() - t.startedAt) / 1000);
+            const status = t.status === "running" ? "running" : `${t.status}${t.exitCode !== null ? `(${t.exitCode})` : ""}`;
+            return `${t.id}  ${status}  ${age}s  ${t.command}`;
+        });
+        return "id  status  age  command\n" + rows.join("\n");
+    }
+    hasRunning() {
+        return [...this.tasks.values()].some((t) => t.status === "running");
+    }
+    runningSummary() {
+        return [...this.tasks.values()]
+            .filter((t) => t.status === "running")
+            .map((t) => `${t.id}: ${t.command}`);
+    }
+    killAll() {
+        for (const t of this.tasks.values()) {
+            if (t.status === "running") {
+                t.status = "stopped";
+                try {
+                    (0, shell_1.killTree)(t.proc.pid);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+    }
+    unknownTask(taskId) {
+        const known = [...this.tasks.keys()].join(", ") || "none";
+        return `Error: no task with id "${taskId}". Known tasks: ${known}. Use task {"action": "list"} to see them.`;
+    }
+}
+exports.TaskManager = TaskManager;

package/dist/tui/editor.js

@@ -0,0 +1,134 @@
+"use strict";
+// Line editor state: a buffer + cursor index, with logical-line navigation
+// for multi-line input, and a wrap-aware layout used by the renderer.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineEditor = void 0;
+exports.layoutBuffer = layoutBuffer;
+class LineEditor {
+    buffer = "";
+    cursor = 0;
+    insert(text) {
+        this.buffer = this.buffer.slice(0, this.cursor) + text + this.buffer.slice(this.cursor);
+        this.cursor += text.length;
+    }
+    backspace() {
+        if (this.cursor === 0)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+        this.cursor--;
+    }
+    del() {
+        if (this.cursor >= this.buffer.length)
+            return;
+        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+    }
+    left() {
+        if (this.cursor > 0)
+            this.cursor--;
+    }
+    right() {
+        if (this.cursor < this.buffer.length)
+            this.cursor++;
+    }
+    lineStartIdx() {
+        return this.buffer.lastIndexOf("\n", this.cursor - 1) + 1;
+    }
+    lineEndIdx() {
+        const nl = this.buffer.indexOf("\n", this.cursor);
+        return nl < 0 ? this.buffer.length : nl;
+    }
+    home() {
+        this.cursor = this.lineStartIdx();
+    }
+    end() {
+        this.cursor = this.lineEndIdx();
+    }
+    /** Line the cursor is on (0-based) and column within it. */
+    lineCol() {
+        const before = this.buffer.slice(0, this.cursor);
+        const line = (before.match(/\n/g) ?? []).length;
+        const col = this.cursor - this.lineStartIdx();
+        return { line, col };
+    }
+    lineCount() {
+        return (this.buffer.match(/\n/g) ?? []).length + 1;
+    }
+    /** Move cursor up one logical line; returns false if already on the first. */
+    upLine() {
+        const { line, col } = this.lineCol();
+        if (line === 0)
+            return false;
+        const lines = this.buffer.split("\n");
+        let idx = 0;
+        for (let i = 0; i < line - 1; i++)
+            idx += lines[i].length + 1;
+        this.cursor = idx + Math.min(col, lines[line - 1].length);
+        return true;
+    }
+    downLine() {
+        const { line, col } = this.lineCol();
+        const lines = this.buffer.split("\n");
+        if (line >= lines.length - 1)
+            return false;
+        let idx = 0;
+        for (let i = 0; i <= line; i++)
+            idx += lines[i].length + 1;
+        this.cursor = idx + Math.min(col, lines[line + 1].length);
+        return true;
+    }
+    killToLineStart() {
+        const start = this.lineStartIdx();
+        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(this.cursor);
+        this.cursor = start;
+    }
+    deleteWordBack() {
+        if (this.cursor === 0)
+            return;
+        let i = this.cursor;
+        while (i > 0 && /\s/.test(this.buffer[i - 1]))
+            i--;
+        while (i > 0 && !/\s/.test(this.buffer[i - 1]))
+            i--;
+        this.buffer = this.buffer.slice(0, i) + this.buffer.slice(this.cursor);
+        this.cursor = i;
+    }
+    clear() {
+        this.buffer = "";
+        this.cursor = 0;
+    }
+    set(text) {
+        this.buffer = text;
+        this.cursor = text.length;
+    }
+}
+exports.LineEditor = LineEditor;
+/** Wrap the buffer into display rows of at most `width` chars, tracking where
+ * the cursor lands. Explicit newlines always break a row. */
+function layoutBuffer(buffer, cursor, width) {
+    const rows = [];
+    let row = "";
+    let curRow = 0;
+    let curCol = 0;
+    for (let i = 0; i <= buffer.length; i++) {
+        if (i === cursor) {
+            curRow = rows.length;
+            curCol = row.length;
+        }
+        if (i === buffer.length)
+            break;
+        const ch = buffer[i];
+        if (ch === "\n") {
+            rows.push(row);
+            row = "";
+        }
+        else {
+            row += ch;
+            if (row.length >= width) {
+                rows.push(row);
+                row = "";
+            }
+        }
+    }
+    rows.push(row);
+    return { rows, curRow, curCol };
+}