@sealant/mend 0.22.0 → 0.24.0

package/dist/service-init.js

@@ -1,227 +0,0 @@
-/**
- * `mend service init` — the mend.toml scaffolder (docs/SESSION-SERVICES.md).
- * Static suggestion, not detection: an offline read of manifests the project
- * already ships (package.json scripts, compose files), producing a proposal
- * the user confirms and commits. Nothing runs; nothing is observed.
- *
- * Pure functions here; the command in main.ts does the I/O.
- */
-/** Scripts that mean "a server" in practice; dev first, the rest as extras. */
-const SERVER_SCRIPTS = ["dev", "start", "serve", "preview"];
-/** Tool defaults for when the script names no port. */
-const TOOL_PORTS = [
-    [/\bvite\b(?!.*build)/, 5173],
-    [/\bnext dev\b/, 3000],
-    [/\bnuxt\b/, 3000],
-    [/\bastro dev\b/, 4321],
-    [/\bremix\b/, 3000],
-];
-const portFromScript = (script) => {
-    const explicit = /(?:--port[= ]|(?<![\w-])-p[= ])(\d{2,5})/.exec(script) ?? /\bPORT=(\d{2,5})/.exec(script);
-    if (explicit?.[1] !== undefined) {
-        const port = Number(explicit[1]);
-        if (port >= 1 && port <= 65535)
-            return { port, guessed: false };
-    }
-    for (const [pattern, port] of TOOL_PORTS) {
-        if (pattern.test(script))
-            return { port, guessed: true };
-    }
-    return null;
-};
-const packageManagerOf = (lockfiles) => {
-    if (lockfiles.includes("pnpm-lock.yaml"))
-        return "pnpm";
-    if (lockfiles.includes("yarn.lock"))
-        return "yarn";
-    if (lockfiles.includes("bun.lockb") || lockfiles.includes("bun.lock"))
-        return "bun";
-    return "npm";
-};
-/** Proposals from package.json scripts. `files` = names present in the repo root. */
-export const proposeFromPackageJson = (packageJsonText, rootFiles) => {
-    let parsed;
-    try {
-        parsed = JSON.parse(packageJsonText);
-    }
-    catch {
-        return [];
-    }
-    if (typeof parsed !== "object" || parsed === null)
-        return [];
-    const scripts = parsed.scripts;
-    if (typeof scripts !== "object" || scripts === null)
-        return [];
-    const pm = packageManagerOf(rootFiles);
-    const proposals = [];
-    for (const scriptName of SERVER_SCRIPTS) {
-        const script = scripts[scriptName];
-        if (typeof script !== "string")
-            continue;
-        const port = portFromScript(script);
-        if (port === null)
-            continue; // no port, no Service — the user can add one by hand
-        proposals.push({
-            name: scriptName === "dev" ? "web" : scriptName,
-            command: `${pm} run ${scriptName}`,
-            port: port.port,
-            protocol: "tcp",
-            guessed: port.guessed,
-            source: `package.json "${scriptName}": ${script}`,
-        });
-        break; // one entry from scripts — the first server-ish one wins
-    }
-    return proposals;
-};
-/**
- * Proposals from a compose file: every service with a published port becomes
- * `docker compose up <name>` at the HOST side of the first mapping — that is
- * where the workspace's docker sidecar publishes it.
- */
-export const proposeFromCompose = (composeText) => {
-    // Deliberately narrow YAML reading: top-level `services:`, two-space
-    // indented names, `ports:` entries as "- host:container". A full YAML
-    // parser is not worth a dependency for a suggestion.
-    const proposals = [];
-    const lines = composeText.split("\n");
-    let inServices = false;
-    let current = null;
-    let inPorts = false;
-    for (const line of lines) {
-        if (/^services:\s*$/.test(line)) {
-            inServices = true;
-            continue;
-        }
-        if (inServices && /^\S/.test(line)) {
-            inServices = false; // left the services block
-        }
-        if (!inServices)
-            continue;
-        const serviceHead = /^ {2}([A-Za-z0-9._-]+):\s*$/.exec(line);
-        if (serviceHead?.[1] !== undefined) {
-            current = serviceHead[1];
-            inPorts = false;
-            continue;
-        }
-        if (current === null)
-            continue;
-        if (/^\s+ports:\s*$/.test(line)) {
-            inPorts = true;
-            continue;
-        }
-        if (inPorts) {
-            const mapping = /^\s+-\s+["']?(\d{2,5}):/.exec(line) ??
-                /^\s+-\s+["']?\$\{[A-Z_a-z0-9]+:-(\d{2,5})\}:/.exec(line) ??
-                /^\s+-\s+["']?(\d{2,5})["']?\s*$/.exec(line);
-            if (mapping?.[1] !== undefined) {
-                const port = Number(mapping[1]);
-                const protocol = /\/udp["']?\s*$/.test(line) ? "udp" : "tcp";
-                if (port >= 1 && port <= 65535 && !proposals.some((p) => p.name === current)) {
-                    proposals.push({
-                        name: current,
-                        command: `docker compose up ${current}`,
-                        port,
-                        protocol,
-                        guessed: false,
-                        source: `compose service "${current}" publishes :${mapping[1]}${protocol === "udp" ? "/udp" : ""}`,
-                    });
-                }
-                inPorts = false; // first mapping wins
-                continue;
-            }
-            if (!/^\s+-/.test(line))
-                inPorts = false;
-        }
-    }
-    return proposals;
-};
-/** Any compose flavor counts: compose.yaml, docker-compose.yml, compose.dev.yaml… */
-export const isComposeFile = (name) => /^(docker-)?compose(\.[\w.-]+)?\.ya?ml$/.test(name);
-/** Workspace dir globs from pnpm-workspace.yaml / package.json "workspaces". Single-level only. */
-export const workspaceGlobs = (pnpmWorkspaceText, packageJsonText) => {
-    const globs = [];
-    if (pnpmWorkspaceText !== null) {
-        let inPackages = false;
-        for (const line of pnpmWorkspaceText.split("\n")) {
-            if (/^packages:\s*$/.test(line)) {
-                inPackages = true;
-                continue;
-            }
-            if (inPackages && /^\S/.test(line))
-                inPackages = false;
-            if (!inPackages)
-                continue;
-            const entry = /^\s+-\s+["']?([^"'#]+?)["']?\s*$/.exec(line);
-            if (entry?.[1] !== undefined && !entry[1].startsWith("!"))
-                globs.push(entry[1].trim());
-        }
-    }
-    if (packageJsonText !== null) {
-        try {
-            const parsed = JSON.parse(packageJsonText);
-            if (Array.isArray(parsed.workspaces)) {
-                globs.push(...parsed.workspaces.filter((g) => typeof g === "string"));
-            }
-        }
-        catch {
-            // no workspaces to read
-        }
-    }
-    return globs;
-};
-/** A workspace package's proposal: named after its folder, run through the package manager. */
-export const proposeFromWorkspacePackage = (dirName, packageJsonText, rootFiles) => {
-    let parsed;
-    try {
-        parsed = JSON.parse(packageJsonText);
-    }
-    catch {
-        return [];
-    }
-    if (typeof parsed !== "object" || parsed === null)
-        return [];
-    const pkg = parsed;
-    const scripts = pkg.scripts;
-    if (typeof scripts !== "object" || scripts === null)
-        return [];
-    const pkgName = typeof pkg.name === "string" ? pkg.name : dirName;
-    const pm = packageManagerOf(rootFiles);
-    const runner = pm === "pnpm"
-        ? (script) => `pnpm --filter ${pkgName} ${script}`
-        : pm === "yarn"
-            ? (script) => `yarn workspace ${pkgName} ${script}`
-            : (script) => `${pm} run ${script} --workspace ${pkgName}`;
-    for (const scriptName of SERVER_SCRIPTS) {
-        const script = scripts[scriptName];
-        if (typeof script !== "string")
-            continue;
-        const port = portFromScript(script);
-        if (port === null)
-            continue;
-        return [
-            {
-                name: dirName,
-                command: runner(scriptName),
-                port: port.port,
-                protocol: "tcp",
-                guessed: port.guessed,
-                source: `${dirName}/package.json "${scriptName}": ${script}`,
-            },
-        ];
-    }
-    return [];
-};
-/** The proposal as the file the user will commit. */
-export const renderMendToml = (proposals) => {
-    const blocks = proposals.map((proposal) => {
-        const lines = [
-            `# ${proposal.source}`,
-            `[service.${proposal.name}]`,
-            `command = ${JSON.stringify(proposal.command)}`,
-            proposal.guessed ? `port = ${proposal.port} # guessed — verify` : `port = ${proposal.port}`,
-            ...(proposal.protocol === "udp" ? [`protocol = "udp"`] : []),
-        ];
-        return lines.join("\n");
-    });
-    return `${blocks.join("\n\n")}\n`;
-};

package/dist/shared.js

@@ -1,338 +0,0 @@
-import { spawnSync } from "node:child_process";
-import * as path from "node:path";
-/**
- * Facts both entry points need: how each harness launches and resumes, which
- * session statuses mean "live", and how a cwd resolves to an adopted project.
- * Kept dependency-free so main.ts stays runnable on plain Node >= 22.
- */
-export const HARNESS_COMMANDS = {
-    codex: ["codex"],
-    claude: ["claude"],
-    opencode: ["opencode"],
-    // Not a coding agent: a plain bash session in its own recorded worktree.
-    shell: ["bash"],
-};
-/** How each harness takes an instruction as its opening prompt. */
-export const CONTINUE_COMMANDS = {
-    codex: (instruction) => ["codex", instruction],
-    claude: (instruction) => ["claude", instruction],
-    opencode: (instruction) => ["opencode", "run", instruction],
-};
-/** Mirror of @mend/domain/workbench harness-launch.ts — the CLI ships dependency-free. */
-export const EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
-/**
- * Ids of optimistic cache rows the server has not named yet — a session still
- * provisioning, a review comment still saving. Anything that would send such
- * an id to the server checks here first and waits instead.
- */
-export const PENDING_ID_PREFIX = "pending:";
-export const pendingId = () => `${PENDING_ID_PREFIX}${crypto.randomUUID()}`;
-export const isPendingId = (id) => id.startsWith(PENDING_ID_PREFIX);
-const LAUNCH_ERROR = {
-    project: null,
-    prompt: null,
-    model: null,
-    effort: null,
-    base: null,
-    name: null,
-    worktree: null,
-    ask: false,
-    fast: false,
-    detach: false,
-    foreground: false,
-    custom: [],
-};
-/**
- * `mend claude|codex|opencode ["prompt"] [--model <id>] [--effort <level>]
- * [--base <ref>] [--ask] [--detach|-d] [--foreground] [--project <p>]`, plus
- * `mend run … -- <command...>`.
- * The first non-flag positional is the prompt; a second one is an error so a
- * forgotten quote fails loudly instead of launching with half a sentence.
- */
-export const parseLaunchArgs = (args) => {
-    const dashdash = args.indexOf("--");
-    const custom = dashdash === -1 ? [] : args.slice(dashdash + 1);
-    const flagArgs = dashdash === -1 ? args : args.slice(0, dashdash);
-    let project = null;
-    let prompt = null;
-    let model = null;
-    let effort = null;
-    let base = null;
-    let workName = null;
-    let joinWorktree = null;
-    let ask = false;
-    let fast = false;
-    let detach = false;
-    let foreground = false;
-    for (let index = 0; index < flagArgs.length; index += 1) {
-        const arg = flagArgs[index] ?? "";
-        if (arg === "--ask") {
-            ask = true;
-            continue;
-        }
-        if (arg === "--fast") {
-            fast = true;
-            continue;
-        }
-        if (arg === "--detach" || arg === "-d") {
-            detach = true;
-            continue;
-        }
-        if (arg === "--foreground") {
-            foreground = true;
-            continue;
-        }
-        if (arg === "--project" ||
-            arg === "--model" ||
-            arg === "--effort" ||
-            arg === "--base" ||
-            arg === "--name" ||
-            arg === "--worktree") {
-            const value = flagArgs[index + 1];
-            if (value === undefined)
-                return { ...LAUNCH_ERROR, error: `${arg} needs a value` };
-            if (arg === "--project")
-                project = value;
-            else if (arg === "--model")
-                model = value;
-            else if (arg === "--effort")
-                effort = value;
-            else if (arg === "--name")
-                workName = normalizeProjectName(value);
-            else if (arg === "--worktree")
-                joinWorktree = value;
-            else
-                base = value;
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith("-")) {
-            // Also catches a prompt starting with "-", which the harness would
-            // otherwise read as a flag of its own.
-            return {
-                ...LAUNCH_ERROR,
-                error: `unknown flag ${arg} — quote the prompt if it starts with "-"`,
-            };
-        }
-        if (prompt !== null) {
-            return {
-                ...LAUNCH_ERROR,
-                error: 'one prompt only — quote it: mend claude "fix the auth test"',
-            };
-        }
-        prompt = arg;
-    }
-    if (effort !== null && !EFFORT_LEVELS.includes(effort)) {
-        return { ...LAUNCH_ERROR, error: `--effort must be one of ${EFFORT_LEVELS.join(", ")}` };
-    }
-    if (detach && foreground) {
-        return { ...LAUNCH_ERROR, error: "--detach and --foreground contradict — pick one" };
-    }
-    if (workName !== null && joinWorktree !== null) {
-        return {
-            ...LAUNCH_ERROR,
-            error: "--name and --worktree contradict — --name names (or joins), --worktree only joins",
-        };
-    }
-    return {
-        project,
-        prompt,
-        model,
-        effort,
-        base,
-        name: workName,
-        worktree: joinWorktree,
-        ask,
-        fast,
-        detach,
-        foreground,
-        custom,
-        error: null,
-    };
-};
-/**
- * Whether a raw stdin chunk carries the detach key (Ctrl+]). Two encodings
- * reach us: the legacy control byte 0x1d — and, once an inner TUI (claude)
- * pushes the kitty keyboard protocol through the PTY and the user's own
- * terminal honors it, the CSI-u escape `ESC [ 93 ; 5 u` (`]` is code 93,
- * ctrl is modifier 5), optionally with a kitty event-type suffix. Only press
- * (`:1`) and repeat (`:2`) are intent; a release (`:3`) is not.
- */
-export const isDetachChunk = (data) => {
-    if (data.includes(0x1d))
-        return true;
-    return csiUKeysOf(data).some((key) => key.code === 93 && isCtrlChord(key) && isPressOrRepeat(key));
-};
-/**
- * What to call a session's worktree in banners and rows: a NAMED worktree is
- * its branch minus the `mend/` prefix; an unnamed one (`mend/session/<uuid>`)
- * is called by its auto-name label, or its short id before one lands.
- */
-export const sessionDisplayName = (session) => {
-    if (session.branch.startsWith("mend/") && !session.branch.startsWith("mend/session/")) {
-        return session.branch.slice("mend/".length);
-    }
-    if (!session.branch.startsWith("mend/session/"))
-        return session.branch;
-    return session.label ?? `session ${session.id.slice(0, 8)}`;
-};
-export const LIVE_STATUSES = new Set([
-    "starting",
-    "running",
-    "waiting",
-    "idle",
-]);
-/**
- * Whether the session's AGENT is live. Session status is a fold over every process — a session
- * reads `idle` while a shell holds the workspace after its agent ended — so the agent's own row
- * answers when one exists; `starting` is a launch with no row yet.
- */
-export const agentIsLive = (session, currentAgent) => currentAgent === null
-    ? LIVE_STATUSES.has(session.status)
-    : session.status === "starting" ||
-        (currentAgent.exitedAt === null &&
-            (currentAgent.status === "starting" || currentAgent.status === "running"));
-/** What an ended agent process's exit says about the work; null while it runs. */
-export const agentOutcome = (currentAgent) => {
-    if (currentAgent === null || currentAgent.exitedAt === null)
-        return null;
-    if (currentAgent.status === "stopped")
-        return "stopped";
-    if (currentAgent.harness === "shell")
-        return "completed";
-    return currentAgent.exitCode === null || currentAgent.exitCode === 0 ? "completed" : "failed";
-};
-/**
- * A git remote URL reduced to `host/owner/name` so https, ssh, scp-style, and
- * `.git` spellings of the same repository compare equal. Null for anything
- * that is not a URL-ish remote (a local path stays a path).
- */
-export const normalizeRemoteUrl = (raw) => {
-    if (raw === null)
-        return null;
-    const trimmed = raw.trim();
-    if (trimmed === "")
-        return null;
-    const scp = /^(?:[^@\s/]+@)?([^:/\s]+):(?!\/)(.+)$/.exec(trimmed);
-    const url = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([^/\s:]+)(?::\d+)?\/(.+)$/i.exec(trimmed);
-    const parts = url ?? scp;
-    if (parts === null)
-        return null;
-    const [, host, rest] = parts;
-    if (host === undefined || rest === undefined)
-        return null;
-    const repoPath = rest.replace(/\/+$/, "").replace(/\.git$/i, "");
-    return `${host.toLowerCase()}/${repoPath.toLowerCase()}`;
-};
-/**
- * The cwd's adopted project, in order: a project adopted from this very
- * path; a project whose origin is the same remote as the cwd repo's origin
- * (normalized, so a GitHub-adopted project matches a clone of it anywhere);
- * a project named like the repository root (through the same normalization
- * adopt uses, so a checkout called "Mend" matches the project "mend").
- */
-export const matchProjectByCwd = (projects, facts) => {
-    const root = facts.repoRoot ?? facts.cwd;
-    const byPath = projects.find((p) => p.originUrl !== null &&
-        !p.originUrl.includes("://") &&
-        (root === p.originUrl ||
-            facts.cwd === p.originUrl ||
-            facts.cwd.startsWith(`${p.originUrl}/`)));
-    if (byPath !== undefined)
-        return byPath;
-    const remote = normalizeRemoteUrl(facts.originUrl);
-    const byRemote = remote === null ? undefined : projects.find((p) => normalizeRemoteUrl(p.originUrl) === remote);
-    if (byRemote !== undefined)
-        return byRemote;
-    const name = normalizeProjectName(path.basename(root));
-    return projects.find((p) => p.name === name);
-};
-/** Read the cwd's facts from git once; callers pass them to the matcher. */
-export const cwdFacts = (cwd) => ({
-    cwd,
-    repoRoot: gitTopLevel(cwd),
-    originUrl: gitOriginUrl(cwd),
-});
-/** The branch checked out at `cwd`, or null outside a repo or on a detached HEAD. */
-export const gitCurrentBranch = (cwd) => {
-    const result = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, encoding: "utf8" });
-    const out = result.status === 0 ? result.stdout.trim() : "";
-    return out === "" || out === "HEAD" ? null : out;
-};
-/** The cwd repo's origin remote, or null when there is no repo or no origin. */
-export const gitOriginUrl = (cwd) => {
-    const result = spawnSync("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
-    const out = result.status === 0 ? result.stdout.trim() : "";
-    return out === "" ? null : out;
-};
-/** The repository root of `cwd`, or null when it is not inside a git repo. */
-export const gitTopLevel = (cwd) => {
-    const result = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" });
-    return result.status === 0 ? result.stdout.trim() : null;
-};
-/**
- * The store's name charset is /^[a-z0-9][a-z0-9._-]{0,63}$/ (server-enforced).
- * Derived defaults (a directory called "Mend") get normalized instead of
- * bounced; an explicit --name is sent as typed so the server's rule teaches.
- */
-export const normalizeProjectName = (raw) => {
-    const slug = raw
-        .toLowerCase()
-        .replace(/[^a-z0-9._-]+/g, "-")
-        .replace(/^[^a-z0-9]+/, "")
-        .replace(/-+$/, "");
-    return slug === "" ? "project" : slug.slice(0, 64);
-};
-// Built from a string: an escape byte inside a regex literal trips lint.
-const CSI_U = new RegExp(`${String.fromCharCode(0x1b)}\\[(\\d+)(?::\\d*)*(?:;(\\d+)(?::(\\d+))?)?(?:;[\\d:]+)?u`, "g");
-const LOCK_MODIFIERS = 64 | 128;
-/** Every CSI-u key report inside a chunk, in order. */
-export const csiUKeysOf = (data) => {
-    // latin1 maps bytes 1:1, so the scan sees exactly the wire bytes.
-    const text = data.toString("latin1");
-    const keys = [];
-    for (const match of text.matchAll(CSI_U)) {
-        const code = Number(match[1]);
-        const mods = (match[2] === undefined ? 1 : Number(match[2])) - 1;
-        const event = match[3] === undefined ? 1 : Number(match[3]);
-        keys.push({ code, mods: mods & ~LOCK_MODIFIERS, event });
-    }
-    return keys;
-};
-const CTRL = 4;
-const SHIFT = 1;
-/** Ctrl held, optionally shift, nothing else (alt/super/hyper/meta make it another chord). */
-const isCtrlChord = (key) => (key.mods & ~SHIFT) === CTRL;
-const isPressOrRepeat = (key) => key.event === 1 || key.event === 2;
-/**
- * Whether one stdin chunk is Ctrl+V — the raw 0x16 byte on its own, or one
- * CSI-u report of `v` (118) or `V` (86) with ctrl, on press or repeat. Exact
- * for the raw byte: a paste that happens to carry 0x16 is not a request.
- */
-export const isPasteChunk = (data) => {
-    if (data.length === 1 && data[0] === 0x16)
-        return true;
-    const keys = csiUKeysOf(data);
-    const key = keys[0];
-    return (keys.length === 1 &&
-        key !== undefined &&
-        (key.code === 118 || key.code === 86) &&
-        isCtrlChord(key) &&
-        isPressOrRepeat(key) &&
-        data.toString("latin1").startsWith("\u001b["));
-};
-/**
- * Follow the remote app's bracketed-paste mode through the bytes it writes:
- * the last `ESC [ ? 2004 h|l` in a chunk wins; a chunk with neither keeps the
- * current state. A pasted image path is wrapped only when the app asked.
- */
-export const trackBracketedPaste = (output, current) => {
-    const text = output.toString("latin1");
-    const on = text.lastIndexOf("\u001b[?2004h");
-    const off = text.lastIndexOf("\u001b[?2004l");
-    if (on === -1 && off === -1)
-        return current;
-    return on > off;
-};
-/** The bytes that paste `text` into the remote app, bracketed when it asked. */
-export const pasteBytes = (text, bracketed) => Buffer.from(bracketed ? `\u001b[200~${text}\u001b[201~` : text, "utf8");