kelocan 0.1.0

package/dist/help.js

@@ -0,0 +1,164 @@
+export const ROOT_HELP = `kelocan — CLI for the Kelocan kanban board (thin client over the REST API)
+
+Usage: kelocan <command> [args] [flags]
+
+Setup:
+  init      Install the kelocan MCP server + agent skills into your agents
+  doctor    Check installed configs, skills, connectivity & auth (read-only)
+  mcp install --agent <name|all>      Write only the MCP config entries
+  skills install --agent <name|all>   Write only the skill files
+  uninstall --agent <name|all>        Remove kelocan MCP entries & skills
+
+Auth:
+  login     Authenticate via browser (loopback) or --api-key
+  logout    Remove stored credentials
+  whoami    Show the current authenticated user
+
+Read:
+  board show <board>                    Show board columns & task counts
+  task list <board> [--column X]        List tasks (filter: --column, --label, --sprint)
+  task show <id>                        Show task detail
+  task prompt <id>                      Print the rendered agent prompt for a task
+
+Write:
+  task create <board> --title "..."     Create a task
+  task move <id> --to <column|role>     Move task to a column
+  task comment <id> -m "..."            Add a comment (-m or --file)
+
+Agent workflow:
+  run start <task> --agent <name>       Open an agent run (prints run_id)
+  run finish <run_id> --outcome <o> -m  Close a run (succeeded|failed|cancelled)
+  subtask list <task>                   List sub-tasks
+  subtask toggle <id>                   Toggle a sub-task done/open
+
+Global flags:
+  --json            Machine-readable JSON output
+  --fields a,b,c    Pick fields (with --json, or tab-separated text)
+  --help, -h        Show help for a command
+
+Config: ~/.config/kelocan/config.json (env KELOCAN_URL / KELOCAN_API_KEY / KELOCAN_WEB_URL override)
+Exit codes: 0 ok · 1 validation · 2 auth · 3 network/server
+
+Run 'kelocan <command> --help' for examples.`;
+export const HELP = {
+    init: `kelocan init — install kelocan MCP + skills into your agents
+
+Usage:
+  kelocan init                              Interactive: login → pick agents → install
+  kelocan init --agent devin,cursor         Non-interactive for selected agents
+  kelocan init --agent all --auth api-key   Force API-key auth headers (env ref)
+Supported agents: devin, claude, cursor, codex, opencode, antigravity, hermes.
+Only the 'kelocan' entry is merged — other MCP entries are never touched, the
+original file is backed up to <config>.bak, and re-running is idempotent.`,
+    doctor: `kelocan doctor — verify the installation (read-only)
+
+Usage: kelocan doctor [--json]
+Checks each detected agent's MCP config entry & URL, installed skill files vs
+the bundled copies, server reachability, and auth. Prints a fix per finding.
+Exit code 1 when any check fails.`,
+    "mcp install": `kelocan mcp install — write only the MCP config entries
+
+Usage: kelocan mcp install --agent <name|all> [--auth oauth|api-key]
+Example: kelocan mcp install --agent codex`,
+    "skills install": `kelocan skills install — write only the skill files
+
+Usage: kelocan skills install --agent <name|all>
+Installs the bundled 'kelocan' and 'kelocan-review' skills into each agent's
+skills directory. Same files can also be installed via
+'npx skills add <owner>/kelocan-cli'.`,
+    uninstall: `kelocan uninstall — remove kelocan from agents
+
+Usage: kelocan uninstall --agent <name|all>
+Removes ONLY the 'kelocan' MCP entry and the kelocan/kelocan-review skill
+directories. Other MCP entries and skills are left untouched (config backed up
+to <config>.bak first).`,
+    login: `kelocan login — authenticate this machine
+
+Usage:
+  kelocan login                          Open browser authorize page (loopback flow)
+  kelocan login --api-key klc_...        Headless: store an existing API key
+  kelocan login --url http://localhost:8001    Point at a different server
+  kelocan login --web-url http://localhost:5173  Override the web app URL
+  kelocan login --name my-laptop         Key name shown in settings
+
+The browser flow opens {web}/cli/authorize?port&state&name and waits for the
+redirect to http://127.0.0.1:<port>/callback?key&state (5 minute timeout).`,
+    logout: `kelocan logout — remove stored credentials
+
+Usage: kelocan logout
+Removes api_key from ~/.config/kelocan/config.json (server URL is kept).`,
+    whoami: `kelocan whoami — show the current user
+
+Usage: kelocan whoami [--json]
+Example: kelocan whoami --fields name,email`,
+    "board show": `kelocan board show — show a board's columns and tasks
+
+Usage: kelocan board show <board>
+  <board> may be a board name or UUID.
+Examples:
+  kelocan board show kanban
+  kelocan board show d8d28757-... --json`,
+    "task list": `kelocan task list — list tasks on a board
+
+Usage: kelocan task list <board> [filters]
+  --column <name|role|uuid>   Filter by column (role: backlog|active|review|done)
+  --label <name|uuid>         Filter by label (repeat via comma: --label bug,cli)
+  --sprint <active|backlog|uuid>  Filter by sprint
+Examples:
+  kelocan task list kanban --column "In Progress"
+  kelocan task list kanban --column review --json --fields id,title`,
+    "task show": `kelocan task show — task detail
+
+Usage: kelocan task show <task-id> [--json]
+Example: kelocan task show 8c8fb91c-... --fields title,description`,
+    "task prompt": `kelocan task prompt — print the agent prompt for a task
+
+Usage: kelocan task prompt <task-id>
+Prints the rendered prompt (work or review variant) to stdout.
+Example: kelocan task prompt 8c8fb91c-... > /tmp/prompt.md`,
+    "task create": `kelocan task create — create a task
+
+Usage: kelocan task create <board> --title "..." [options]
+  --column <name|role|uuid>   Target column (default: backlog/"To Do")
+  --description <text>        Task description
+  --kind <task|idea|feedback> Card kind (default: task)
+  --priority <low|medium|high|urgent>  (default: medium)
+  --label <name,...>          Attach labels by name or UUID
+  --sprint <active|backlog|uuid>       Sprint assignment (default: backlog)
+Examples:
+  kelocan task create kanban --title "Fix login" --column todo --label bug
+  kelocan task create kanban --title "Idea" --kind idea --priority low`,
+    "task move": `kelocan task move — move a task to another column
+
+Usage: kelocan task move <task-id> --to <column|role> [--position N]
+  --to accepts a column name, workflow role (backlog|active|review|done), or UUID.
+Examples:
+  kelocan task move 8c8fb91c-... --to "In Progress"
+  kelocan task move 8c8fb91c-... --to review`,
+    "task comment": `kelocan task comment — add a comment to a task
+
+Usage: kelocan task comment <task-id> (-m "text" | --file path)
+  -m, --message <text>   Comment body
+  --file <path>          Attach a file (repeat via comma). With no -m, a text
+                         file's content becomes the comment body.
+Examples:
+  kelocan task comment 8c8fb91c-... -m "Progress: 50%"
+  kelocan task comment 8c8fb91c-... -m "see log" --file build.log`,
+    "run start": `kelocan run start — open an agent run on a task
+
+Usage: kelocan run start <task-id> --agent <name> [--status "text"]
+Prints the run_id — keep it for 'run finish'.
+Example: kelocan run start 8c8fb91c-... --agent "Devin" --status "Investigating"`,
+    "run finish": `kelocan run finish — close an agent run
+
+Usage: kelocan run finish <run-id> --outcome <succeeded|failed|cancelled> [-m "summary"]
+Example: kelocan run finish ca01614d-... --outcome succeeded -m "PR opened"`,
+    "subtask list": `kelocan subtask list — list a task's sub-tasks
+
+Usage: kelocan subtask list <task-id> [--json]
+Example: kelocan subtask list 8c8fb91c-...`,
+    "subtask toggle": `kelocan subtask toggle — toggle a sub-task done/open
+
+Usage: kelocan subtask toggle <subtask-id>
+Example: kelocan subtask toggle 8e19ca38-...`,
+};

package/dist/install.js

@@ -0,0 +1,172 @@
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { homedir } from "node:os";
+import { binOnPath, detectAgent, jsonEntry, removeTomlEntry, removeYamlEntry, resolveConfigPath, tomlEntry, upsertTomlEntry, upsertYamlEntry, yamlEntry, } from "./agents.js";
+import { apiBase, readConfig } from "./config.js";
+import { CliError } from "./errors.js";
+import { removeJsonEntry, upsertJsonEntry } from "./jsonc.js";
+import { installSkills, removeSkills } from "./skills.js";
+/** Public MCP endpoint for the Kelocan server (env KELOCAN_MCP_URL wins). */
+export function mcpUrl() {
+    if (process.env.KELOCAN_MCP_URL)
+        return process.env.KELOCAN_MCP_URL.replace(/\/+$/, "");
+    const base = apiBase(readConfig()).replace(/\/api\/v1$/, "");
+    return `${base}/mcp`;
+}
+function backupOnce(path) {
+    if (!existsSync(path))
+        return null;
+    const bak = `${path}.bak`;
+    copyFileSync(path, bak);
+    return bak;
+}
+function writeFile(path, text) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, text);
+}
+/** Write the kelocan MCP entry into an agent's config (or via its CLI). */
+export function installMcpConfig(def, auth, home = homedir(), url = mcpUrl()) {
+    // Claude Code: prefer `claude mcp add` when the binary exists.
+    if (def.cli && binOnPath(def.cli.bin)) {
+        const existing = readFileSafe(resolveConfigPath(def, home));
+        let already = false;
+        if (existing) {
+            try {
+                const parsed = JSON.parse(existing);
+                already = parsed.mcpServers?.kelocan !== undefined;
+            }
+            catch {
+                /* fall through to CLI */
+            }
+        }
+        if (already) {
+            return { configPath: resolveConfigPath(def, home), action: "unchanged", viaCli: true };
+        }
+        const r = spawnSync(def.cli.bin, def.cli.args(url), { encoding: "utf8" });
+        if (r.status === 0) {
+            return { configPath: resolveConfigPath(def, home), action: "cli", viaCli: true };
+        }
+        // fall back to file editing
+    }
+    const path = resolveConfigPath(def, home);
+    const text = readFileSafe(path);
+    let res;
+    switch (def.format) {
+        case "json":
+            res = upsertJsonEntry(text, def.containerKey, "kelocan", jsonEntry(def, url, auth));
+            break;
+        case "toml":
+            res = upsertTomlEntry(text, tomlEntry(url));
+            break;
+        case "yaml":
+            res = upsertYamlEntry(text, yamlEntry(url, auth));
+            break;
+    }
+    if (!res.changed)
+        return { configPath: path, action: "unchanged" };
+    const backup = backupOnce(path);
+    writeFile(path, res.text);
+    return { configPath: path, action: "written", backup };
+}
+/** Remove the kelocan MCP entry (and only that) from an agent's config. */
+export function uninstallMcpConfig(def, home = homedir()) {
+    if (def.cli && binOnPath(def.cli.bin)) {
+        const r = spawnSync(def.cli.bin, ["mcp", "remove", "kelocan"], { encoding: "utf8" });
+        if (r.status === 0) {
+            return { configPath: resolveConfigPath(def, home), action: "cli" };
+        }
+        // fall through to file editing
+    }
+    const path = resolveConfigPath(def, home);
+    const text = readFileSafe(path);
+    if (text === null)
+        return { configPath: path, action: "absent" };
+    let res;
+    switch (def.format) {
+        case "json":
+            res = removeJsonEntry(text, def.containerKey, "kelocan");
+            break;
+        case "toml":
+            res = removeTomlEntry(text);
+            break;
+        case "yaml":
+            res = removeYamlEntry(text);
+            break;
+    }
+    if (!res.changed)
+        return { configPath: path, action: "absent" };
+    const backup = backupOnce(path);
+    writeFile(path, res.text);
+    return { configPath: path, action: "removed", backup };
+}
+function readFileSafe(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Install MCP config + bundled skills for one agent. */
+export function installAgent(det, auth, home = homedir()) {
+    const warnings = [];
+    if (auth === "api-key" && det.def.defaultAuth === "oauth") {
+        warnings.push(`--auth api-key: writing a Bearer header referencing $KELOCAN_API_KEY ` +
+            `(env var — no literal secret is stored).`);
+    }
+    const config = installMcpConfig(det.def, auth, home);
+    const skills = det.skillDirs.map((dir) => ({ dir, results: installSkills(dir) }));
+    return { agent: det.def.id, config, skills, warnings };
+}
+/** Remove kelocan MCP entry + kelocan skills for one agent. */
+export function uninstallAgent(det, home = homedir()) {
+    const config = uninstallMcpConfig(det.def, home);
+    const skillsRemoved = det.skillDirs.flatMap((dir) => removeSkills(dir));
+    return { agent: det.def.id, config, skillsRemoved };
+}
+/**
+ * Verify the MCP endpoint responds: POST a JSON-RPC `initialize`.
+ * Uses the stored API key when present (OAuth installs are verified by the
+ * agent client itself later).
+ */
+export async function probeMcp(url, apiKey) {
+    const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+    };
+    if (apiKey)
+        headers.Authorization = `Bearer ${apiKey}`;
+    const body = JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-03-26",
+            capabilities: {},
+            clientInfo: { name: "kelocan-cli", version: "0.1.0" },
+        },
+    });
+    let res;
+    try {
+        res = await fetch(url, { method: "POST", headers, body });
+    }
+    catch (e) {
+        throw new CliError(`Cannot reach MCP endpoint ${url}: ${e instanceof Error ? e.message : e}`, 3);
+    }
+    if (!res.ok) {
+        throw new CliError(`MCP endpoint ${url} returned HTTP ${res.status}`, res.status === 401 || res.status === 403 ? 2 : 3);
+    }
+    const text = await res.text();
+    // response may be JSON or SSE ("data: {...}")
+    const jsonLine = text
+        .split("\n")
+        .map((l) => l.trim())
+        .find((l) => l.startsWith("{") || l.startsWith("data: {"));
+    const payload = jsonLine ? JSON.parse(jsonLine.replace(/^data:\s*/, "")) : {};
+    const name = payload?.result?.serverInfo?.name;
+    return name ? `connected (server: ${name})` : "connected";
+}
+export { detectAgent };

package/dist/jsonc.js

@@ -0,0 +1,297 @@
+import { CliError } from "./errors.js";
+/**
+ * Minimal JSON/JSONC surgery helpers.
+ * stripJsonc parses leniently (comments + trailing commas removed); the upsert /
+ * remove functions edit the *text* so comments and formatting of other entries
+ * are preserved.
+ */
+export function stripJsonc(text) {
+    let out = "";
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+        const c = text[i];
+        if (c === '"') {
+            const end = skipString(text, i);
+            out += text.slice(i, end);
+            i = end;
+        }
+        else if (c === "/" && text[i + 1] === "/") {
+            while (i < n && text[i] !== "\n")
+                i++;
+        }
+        else if (c === "/" && text[i + 1] === "*") {
+            i += 2;
+            while (i < n && !(text[i] === "*" && text[i + 1] === "/"))
+                i++;
+            i += 2;
+        }
+        else {
+            out += c;
+            i++;
+        }
+    }
+    // trailing commas: ",}" or ",]" outside strings
+    return out.replace(/,(\s*[}\]])/g, "$1");
+}
+export function parseJsonc(text) {
+    try {
+        return JSON.parse(stripJsonc(text));
+    }
+    catch (e) {
+        throw new CliError(`Config file is not valid JSON: ${e instanceof Error ? e.message : e}`);
+    }
+}
+function skipWs(text, i) {
+    const n = text.length;
+    while (i < n) {
+        const c = text[i];
+        if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+            i++;
+        }
+        else if (c === "/" && text[i + 1] === "/") {
+            while (i < n && text[i] !== "\n")
+                i++;
+        }
+        else if (c === "/" && text[i + 1] === "*") {
+            i += 2;
+            while (i < n && !(text[i] === "*" && text[i + 1] === "/"))
+                i++;
+            i += 2;
+        }
+        else {
+            break;
+        }
+    }
+    return i;
+}
+function skipString(text, i) {
+    // i is at opening quote
+    i++;
+    const n = text.length;
+    while (i < n) {
+        const c = text[i];
+        if (c === "\\")
+            i += 2;
+        else if (c === '"')
+            return i + 1;
+        else
+            i++;
+    }
+    return i;
+}
+function skipValue(text, i) {
+    i = skipWs(text, i);
+    const c = text[i];
+    if (c === '"')
+        return skipString(text, i);
+    if (c === "{" || c === "[") {
+        const open = c;
+        const close = open === "{" ? "}" : "]";
+        let depth = 1;
+        i++;
+        const n = text.length;
+        while (i < n && depth > 0) {
+            const ch = text[i];
+            if (ch === '"') {
+                i = skipString(text, i);
+            }
+            else if (ch === "/" && (text[i + 1] === "/" || text[i + 1] === "*")) {
+                i = skipWs(text, i);
+            }
+            else {
+                if (ch === open)
+                    depth++;
+                else if (ch === close)
+                    depth--;
+                i++;
+            }
+        }
+        return i;
+    }
+    // literal: number/true/false/null
+    const m = /^[a-zA-Z0-9_+\-.eE]+/.exec(text.slice(i));
+    return i + (m ? m[0].length : 1);
+}
+function matchingBrace(text, openIdx) {
+    // openIdx at '{'
+    let depth = 1;
+    let i = openIdx + 1;
+    const n = text.length;
+    while (i < n && depth > 0) {
+        const ch = text[i];
+        if (ch === '"')
+            i = skipString(text, i);
+        else if (ch === "/" && (text[i + 1] === "/" || text[i + 1] === "*"))
+            i = skipWs(text, i);
+        else {
+            if (ch === "{")
+                depth++;
+            else if (ch === "}")
+                depth--;
+            i++;
+        }
+    }
+    return i - 1; // index of '}'
+}
+function listMembers(text, openBrace, closeBrace) {
+    const members = [];
+    let i = openBrace + 1;
+    let pendingComma = -1;
+    while (true) {
+        i = skipWs(text, i);
+        if (i >= closeBrace)
+            break;
+        if (text[i] === ",") {
+            pendingComma = i;
+            i++;
+            continue;
+        }
+        if (text[i] !== '"') {
+            throw new CliError("Config file structure is not a plain JSON object.");
+        }
+        const keyStart = i;
+        const keyEnd = skipString(text, i);
+        const key = text.slice(keyStart + 1, keyEnd - 1);
+        i = skipWs(text, keyEnd);
+        if (text[i] !== ":") {
+            throw new CliError("Config file structure is not a plain JSON object.");
+        }
+        const valueStart = skipWs(text, i + 1);
+        const valueEnd = skipValue(text, valueStart);
+        members.push({
+            key,
+            keyStart,
+            colonIdx: i,
+            valueStart,
+            valueEnd,
+            commaAfter: -1,
+            commaBefore: pendingComma,
+        });
+        pendingComma = -1;
+        i = skipWs(text, valueEnd);
+        if (text[i] === ",") {
+            members[members.length - 1].commaAfter = i;
+            pendingComma = i;
+            i++;
+        }
+    }
+    return members;
+}
+/** Detect the indent used by members of an object (first member's leading ws). */
+function memberIndent(text, members, fallbackIndent) {
+    if (members.length === 0)
+        return fallbackIndent;
+    const first = members[0];
+    const lineStart = text.lastIndexOf("\n", first.keyStart) + 1;
+    const ws = /^[ \t]*/.exec(text.slice(lineStart, first.keyStart))?.[0] ?? "";
+    return ws || fallbackIndent;
+}
+function rootObject(text) {
+    const open = skipWs(text, 0);
+    if (text[open] !== "{") {
+        throw new CliError("Config file does not contain a top-level JSON object.");
+    }
+    return { open, close: matchingBrace(text, open) };
+}
+function inlineValue(value) {
+    return JSON.stringify(value);
+}
+/** Pretty-print with continuation lines aligned to `indent`. */
+function prettyValue(value, indent) {
+    return JSON.stringify(value, null, 2).split("\n").join("\n" + indent);
+}
+/**
+ * Insert or replace `entryKey` inside root object's `containerKey` object.
+ * Preserves comments and all other entries. Idempotent: returns changed=false
+ * when the existing entry already deep-equals `entry`.
+ */
+export function upsertJsonEntry(text, containerKey, entryKey, entry) {
+    if (!text || text.trim() === "") {
+        return {
+            text: `{\n  "${containerKey}": {\n    "${entryKey}": ${prettyValue(entry, "    ")}\n  }\n}\n`,
+            changed: true,
+        };
+    }
+    const { open, close } = rootObject(text);
+    const members = listMembers(text, open, close);
+    const container = members.find((m) => m.key === containerKey);
+    const rootIndent = memberIndent(text, members, "  ");
+    if (!container) {
+        const snippet = `"${containerKey}": {\n${rootIndent}  "${entryKey}": ` +
+            `${prettyValue(entry, rootIndent + "  ")}\n${rootIndent}}`;
+        if (members.length === 0) {
+            const out = text.slice(0, open + 1) + ` ${snippet} ` + text.slice(close);
+            return { text: out, changed: true };
+        }
+        const last = members[members.length - 1];
+        const at = last.commaAfter !== -1 ? last.commaAfter + 1 : last.valueEnd;
+        const insertion = `${last.commaAfter !== -1 ? "" : ","}\n${rootIndent}${snippet}`;
+        const out = text.slice(0, at) + insertion + text.slice(at);
+        return { text: out, changed: true };
+    }
+    const cOpen = skipWs(text, container.valueStart);
+    if (text[cOpen] !== "{") {
+        throw new CliError(`Existing "${containerKey}" entry is not an object — refusing to modify it.`);
+    }
+    const cClose = container.valueEnd - 1;
+    const cMembers = listMembers(text, cOpen, cClose);
+    const cIndent = memberIndent(text, cMembers, rootIndent + "  ");
+    const existing = cMembers.find((m) => m.key === entryKey);
+    if (existing) {
+        const parsed = parseJsonc(text.slice(existing.valueStart, existing.valueEnd));
+        if (JSON.stringify(parsed) === JSON.stringify(entry)) {
+            return { text, changed: false };
+        }
+        const out = text.slice(0, existing.valueStart) +
+            prettyValue(entry, cIndent) +
+            text.slice(existing.valueEnd);
+        return { text: out, changed: true };
+    }
+    if (cMembers.length === 0) {
+        const inner = `{ "${entryKey}": ${inlineValue(entry)} }`;
+        const out = text.slice(0, cOpen) + inner + text.slice(cClose + 1);
+        return { text: out, changed: true };
+    }
+    const last = cMembers[cMembers.length - 1];
+    const at = last.commaAfter !== -1 ? last.commaAfter + 1 : last.valueEnd;
+    const insertion = `${last.commaAfter !== -1 ? "" : ","}\n${cIndent}"${entryKey}": ${prettyValue(entry, cIndent)}`;
+    const out = text.slice(0, at) + insertion + text.slice(at);
+    return { text: out, changed: true };
+}
+/**
+ * Remove `entryKey` from root object's `containerKey` (container kept, even if
+ * it becomes `{}`). Returns changed=false when nothing to remove.
+ */
+export function removeJsonEntry(text, containerKey, entryKey) {
+    if (text.trim() === "")
+        return { text, changed: false };
+    const { open, close } = rootObject(text);
+    const members = listMembers(text, open, close);
+    const container = members.find((m) => m.key === containerKey);
+    if (!container)
+        return { text, changed: false };
+    const cOpen = skipWs(text, container.valueStart);
+    if (text[cOpen] !== "{")
+        return { text, changed: false };
+    const cClose = container.valueEnd - 1;
+    const cMembers = listMembers(text, cOpen, cClose);
+    const target = cMembers.find((m) => m.key === entryKey);
+    if (!target)
+        return { text, changed: false };
+    let cutStart = target.keyStart;
+    let cutEnd = target.valueEnd;
+    if (target.commaAfter !== -1) {
+        cutEnd = target.commaAfter + 1;
+    }
+    else if (target.commaBefore !== -1) {
+        cutStart = target.commaBefore;
+    }
+    // also swallow the trailing newline+indent of the removed line
+    const nl = text.indexOf("\n", cutEnd);
+    if (nl !== -1 && nl < cClose && text.slice(cutEnd, nl).trim() === "") {
+        cutEnd = nl + 1;
+    }
+    const out = text.slice(0, cutStart) + text.slice(cutEnd);
+    return { text: out, changed: true };
+}