@sealant/mend 0.14.0 → 0.15.2

package/dist/main.js

@@ -11,7 +11,7 @@ import { formatLoadReport } from "./env.js";
 import { loginCommand } from "./login.js";
 import { pairCommand, qrCommand } from "./pair.js";
 import { isComposeFile, proposeFromCompose, proposeFromPackageJson, proposeFromWorkspacePackage, renderMendToml, workspaceGlobs, } from "./service-init.js";
-import { agentIsLive, agentOutcome, cwdFacts, gitTopLevel, HARNESS_COMMANDS, isDetachChunk, LIVE_STATUSES, matchProjectByCwd, normalizeProjectName, parseLaunchArgs, } from "./shared.js";
+import { agentIsLive, agentOutcome, cwdFacts, gitTopLevel, HARNESS_COMMANDS, isDetachChunk, LIVE_STATUSES, sessionDisplayName, matchProjectByCwd, normalizeProjectName, gitCurrentBranch, parseLaunchArgs, } from "./shared.js";
 import { sshCommand } from "./ssh-setup.js";
 // `$XDG_CONFIG_HOME/mend`, default `~/.config/mend`; a pre-XDG `~/.mend` stays authoritative
 // when it is the only one present (mirrors @mend/store's resolver — the CLI stays dependency-light).
@@ -284,7 +284,37 @@ const launch = async (config, harness, args) => {
     say(`${green("✓")} project ${project.name} ${dim(`· ${project.defaultBranch}${parsed.project === null ? " · from cwd" : ""}`)}`);
     // The worktree's name comes first, then the session details — it is the
     // identity every list leads with. `mend run` stays scriptable: flag only.
-    const worktreeName = harness === "run" ? parsed.name : (parsed.name ?? (await askWorktreeName()));
+    // `--worktree` insists on joining: the name must already exist here.
+    let worktreeName;
+    if (parsed.worktree !== null) {
+        const detail = await api(config, "GET", `/projects/${project.id}`);
+        const existing = detail.worktrees ?? [];
+        if (detail.worktrees === undefined) {
+            return fail("this server predates shared worktrees — use --name instead");
+        }
+        const match = existing.find((worktree) => worktree.name === parsed.worktree) ??
+            (existing.filter((worktree) => worktree.name.startsWith(parsed.worktree ?? "")).length === 1
+                ? existing.find((worktree) => worktree.name.startsWith(parsed.worktree ?? ""))
+                : undefined);
+        if (match === undefined) {
+            const names = existing.map((worktree) => worktree.name).join(", ");
+            return fail(`no worktree matches "${parsed.worktree}" in ${project.name}${names === "" ? "" : ` — have: ${names}`}`);
+        }
+        worktreeName = match.name;
+    }
+    else {
+        worktreeName = harness === "run" ? parsed.name : (parsed.name ?? (await askWorktreeName()));
+    }
+    // Say when the name joins an existing worktree — a join is a fact worth
+    // stating before the session exists, not a surprise in the tree later.
+    if (worktreeName !== null) {
+        const detail = await api(config, "GET", `/projects/${project.id}`).catch(() => null);
+        const joined = detail?.worktrees?.find((worktree) => worktree.name === worktreeName);
+        if (joined !== undefined) {
+            const members = (detail?.sessions ?? []).filter((candidate) => candidate.worktreeId === joined.id).length;
+            say(`${green("✓")} joins worktree ${joined.name} ${dim(`· ${members} session${members === 1 ? "" : "s"} · branch ${joined.branch}`)}`);
+        }
+    }
     const lifecycle = harness === "run"
         ? "background"
         : parsed.detach
@@ -593,7 +623,7 @@ const attach = async (config, args) => {
     const match = sessions.find((s) => s.id.startsWith(prefix));
     if (match === undefined)
         return fail(`no active session matches "${prefix}"`);
-    say(`${green("✓")} attaching to ${match.branch} · ${match.harness} ${dim(match.id.slice(0, 8))}${detachHint()}`);
+    say(`${green("✓")} attaching to ${sessionDisplayName(match)} · ${match.harness} ${dim(match.id.slice(0, 8))}${detachHint()}`);
     say("");
     await attachOrExit(config, match.id, match.harness);
     exitAfterSessionEnd(config, match.id);
@@ -2067,7 +2097,7 @@ const rejoinCommand = async (config, args) => {
     if (session === undefined)
         return fail("session selection failed");
     const alreadyLive = agentLiveIn(detail, session);
-    say(`${green("✓")} rejoining ${session.branch} · ${session.harness} ${dim(session.id.slice(0, 8))} · ${alreadyLive ? "already live" : "restoring"}`);
+    say(`${green("✓")} rejoining ${sessionDisplayName(session)} · ${session.harness} ${dim(session.id.slice(0, 8))} · ${alreadyLive ? "already live" : "restoring"}`);
     say(`${cobalt("  watch")} · ${config.url}/sessions/${session.id}`);
     let restored = false;
     const currentAgent = detail.annotations.find((annotation) => annotation.sessionId === session.id)?.currentAgent ??
@@ -2168,6 +2198,15 @@ const printSessionRow = (row) => {
  */
 const sessionsCommand = async (config, args) => {
     const all = args.includes("--all");
+    // v1 stays byte-stable for pinned integrations; v2 is the worktree envelope.
+    if (args.includes("--json=v2")) {
+        const projectFlag = args.indexOf("--project");
+        const projectName = projectFlag !== -1 && args[projectFlag + 1] !== undefined
+            ? String(args[projectFlag + 1])
+            : null;
+        say(JSON.stringify(await buildWorktreesJson(config, projectName), null, 2));
+        return;
+    }
     const json = args.includes("--json");
     const projectFlag = args.indexOf("--project");
     const projectName = projectFlag !== -1 && args[projectFlag + 1] !== undefined
@@ -2243,6 +2282,117 @@ const sessionsCommand = async (config, args) => {
     for (const row of rows)
         printSessionRow(row);
 };
+/**
+ * The worktree-grouped view both `mend worktrees --json` and
+ * `mend sessions --json=v2` emit. Against a pre-worktree server every session
+ * becomes its own pseudo worktree (`id: null`) — the envelope shape is stable
+ * either way, so integrations pin on `version`, not server age.
+ */
+const toWorktreeJsonSession = (session) => ({
+    id: session.id,
+    harness: session.harness,
+    label: session.label,
+    status: session.status,
+    summary: session.summary,
+    createdAt: session.createdAt,
+});
+const buildWorktreesJson = async (config, projectName) => {
+    const projects = await api(config, "GET", "/projects");
+    const scope = projectName === null ? projects : projects.filter((p) => p.name === projectName);
+    const details = await Promise.all(scope.map((p) => api(config, "GET", `/projects/${p.id}`)));
+    const worktrees = [];
+    for (const detail of details) {
+        const reviewOf = (sessionIds) => {
+            const facts = detail.annotations.find((a) => sessionIds.has(a.sessionId));
+            return facts === undefined
+                ? null
+                : {
+                    openComments: facts.openComments,
+                    totalComments: facts.totalComments,
+                    pendingFollowUp: detail.annotations.some((a) => sessionIds.has(a.sessionId) && a.pendingFollowUp),
+                };
+        };
+        const urlOf = (sessionIds) => {
+            const first = [...sessionIds][0];
+            return first === undefined ? null : `${config.url.replace(/\/$/, "")}/sessions/${first}`;
+        };
+        if (detail.worktrees !== undefined) {
+            for (const worktree of detail.worktrees) {
+                const members = detail.sessions.filter((session) => session.worktreeId === worktree.id);
+                const ids = new Set(members.map((session) => session.id));
+                worktrees.push({
+                    id: worktree.id,
+                    name: worktree.name,
+                    projectId: detail.project.id,
+                    projectName: detail.project.name,
+                    branch: worktree.branch,
+                    baseSha: worktree.baseSha,
+                    baseRef: worktree.baseRef,
+                    createdAt: worktree.createdAt,
+                    reviewUrl: urlOf(ids),
+                    review: reviewOf(ids),
+                    sessions: members
+                        .toSorted((a, b) => b.createdAt.localeCompare(a.createdAt))
+                        .map(toWorktreeJsonSession),
+                });
+            }
+        }
+        else {
+            for (const session of detail.sessions) {
+                const ids = new Set([session.id]);
+                worktrees.push({
+                    id: null,
+                    name: session.worktree,
+                    projectId: detail.project.id,
+                    projectName: detail.project.name,
+                    branch: session.branch,
+                    baseSha: session.baseSha,
+                    baseRef: session.baseRef,
+                    createdAt: session.createdAt,
+                    reviewUrl: urlOf(ids),
+                    review: reviewOf(ids),
+                    sessions: [toWorktreeJsonSession(session)],
+                });
+            }
+        }
+    }
+    return { version: 2, worktrees };
+};
+/** `mend worktrees [--project <p>] [--json]` — the container-first listing. */
+const worktreesCommand = async (config, args) => {
+    const json = args.includes("--json");
+    const projectFlag = args.indexOf("--project");
+    const projectName = projectFlag !== -1 && args[projectFlag + 1] !== undefined
+        ? String(args[projectFlag + 1])
+        : null;
+    const payload = await buildWorktreesJson(config, projectName);
+    if (json) {
+        say(JSON.stringify(payload, null, 2));
+        return;
+    }
+    if (payload.worktrees.length === 0) {
+        say(dim("no worktrees yet — mend claude --name <worktree> starts one"));
+        return;
+    }
+    for (const worktree of payload.worktrees) {
+        const live = worktree.sessions.filter((session) => ACTIVE_STATUSES.has(session.status)).length;
+        const facts = [
+            `${worktree.sessions.length} session${worktree.sessions.length === 1 ? "" : "s"}`,
+        ];
+        if (live > 0)
+            facts.push(green(`${live} live`));
+        if (worktree.review !== null && worktree.review.openComments > 0) {
+            facts.push(amber(`${worktree.review.openComments} open`));
+        }
+        const base = worktree.baseRef ?? worktree.baseSha.slice(0, 12);
+        say(`${worktree.name.padEnd(24)}  ${worktree.projectName}  ${dim(`${worktree.branch} · base ${base}`)}  ${facts.join(dim(" · "))}`);
+        for (const session of worktree.sessions) {
+            const status = session.status.padEnd(9);
+            const name = session.label ?? `session ${session.id.slice(0, 8)}`;
+            say(`  └ ${session.harness.padEnd(8)}  ${dim(session.id.slice(0, 8))}  ${ACTIVE_STATUSES.has(session.status) ? green(status) : dim(status)}  ${name}`);
+        }
+    }
+};
 // ─── dashboard: the live TUI on bare `mend` ─────────────────────────────────
 const hasNodeFfi = () => {
     try {
@@ -2276,6 +2426,7 @@ const dashboard = async (config) => {
     await runDashboard({
         config,
         cwd: process.cwd(),
+        cwdBranch: gitCurrentBranch(process.cwd()),
         api: (method, route, body) => request(config, method, route, body),
         attachTty: (sessionId, harness, processId) => attachTty(config, sessionId, harness, 0n, processId),
     });
@@ -2295,11 +2446,13 @@ start
   mend adopt [source] [--name <name>] [--auth ambient|mend-key|bridge]
                                         adopt a repository into the store (default: cwd; any git
                                         URL — GitHub, GitLab, self-hosted, ssh://, a local path)
-  mend codex|claude|opencode ["prompt"] [--name <worktree>] [--model <id>]
-                             [--effort low|medium|high|xhigh|max]
+  mend codex|claude|opencode ["prompt"] [--name <worktree>] [--worktree <existing>]
+                             [--model <id>] [--effort low|medium|high|xhigh|max]
                              [--base <ref>] [--ask] [--fast] [--detach|-d] [--foreground]
-                                        new session worktree + launch the harness in it; the
-                                        worktree's name is asked first (--name skips the ask), a
+                                        launch the harness in a worktree; the worktree's name is
+                                        asked first (--name skips the ask — an EXISTING name joins
+                                        that worktree as a new session; --worktree joins only,
+                                        failing if absent), a
                                         quoted prompt becomes its first message,
                                         --ask restores the harness's permission prompts, --fast
                                         requests priority processing (codex service tier),
@@ -2325,6 +2478,9 @@ everything else
   mend keys share                       relay THIS machine's ssh-agent to the server (bridge mode:
                                         hardware keys sign here; Ctrl-C stops sharing)
   mend run -- <command...>              same, with an arbitrary command
+  mend worktrees [--project <p>] [--json]
+                                        every worktree and the sessions inside it (mend sessions
+                                        --json stays the v1 flat list; --json=v2 groups like this)
   mend attach <session-id-prefix>       reattach this terminal to a running session
   mend stop <session-id-prefix> | --all [--project <p>]
                                         stop the agent — the workspace harvests and closes; the
@@ -2421,6 +2577,8 @@ const main = async () => {
         case "sessions":
         case "status":
             return sessionsCommand(config, rest);
+        case "worktrees":
+            return worktreesCommand(config, rest);
         case undefined:
         case "ui":
             return dashboard(config);

package/dist/shared.js

@@ -35,6 +35,7 @@ const LAUNCH_ERROR = {
     effort: null,
     base: null,
     name: null,
+    worktree: null,
     ask: false,
     fast: false,
     detach: false,
@@ -58,6 +59,7 @@ export const parseLaunchArgs = (args) => {
     let effort = null;
     let base = null;
     let workName = null;
+    let joinWorktree = null;
     let ask = false;
     let fast = false;
     let detach = false;
@@ -84,7 +86,8 @@ export const parseLaunchArgs = (args) => {
             arg === "--model" ||
             arg === "--effort" ||
             arg === "--base" ||
-            arg === "--name") {
+            arg === "--name" ||
+            arg === "--worktree") {
             const value = flagArgs[index + 1];
             if (value === undefined)
                 return { ...LAUNCH_ERROR, error: `${arg} needs a value` };
@@ -96,6 +99,8 @@ export const parseLaunchArgs = (args) => {
                 effort = value;
             else if (arg === "--name")
                 workName = normalizeProjectName(value);
+            else if (arg === "--worktree")
+                joinWorktree = value;
             else
                 base = value;
             index += 1;
@@ -123,6 +128,12 @@ export const parseLaunchArgs = (args) => {
     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,
@@ -130,6 +141,7 @@ export const parseLaunchArgs = (args) => {
         effort,
         base,
         name: workName,
+        worktree: joinWorktree,
         ask,
         fast,
         detach,
@@ -161,6 +173,19 @@ export const isDetachChunk = (data) => {
     }
     return false;
 };
+/**
+ * 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",
@@ -238,6 +263,12 @@ export const cwdFacts = (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" });

package/dist/tui-theme.js

@@ -23,6 +23,11 @@ export const RULE = "#37374a";
 export const COBALT = "#6f96f5";
 /** The selection wash: a neutral lifted row — visible, not colorful. */
 export const WASH = "#2c2c35";
+/**
+ * The one exception to the no-painted-background rule: a floating modal
+ * must occlude the content beneath it, so it owns its ground.
+ */
+export const SURFACE = "#17171d";
 export const AMBER = "#e2ab42";
 export const GREEN = "#69c189";
 export const RED = "#e87f76";

package/dist/workbench-events.js

@@ -55,6 +55,7 @@ export const eventFamilies = (payload) => {
         return [];
     switch (parsed.type) {
         case "project":
+        case "worktree":
         case "session-process":
             return ["workbench"];
         // Session facts feed both surfaces: rows and annotations on the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealant/mend",
-  "version": "0.14.0",
+  "version": "0.15.2",
   "description": "The mend CLI: adopt a repository into Mend's store, launch your coding agent in a recorded session worktree, detach and reattach from any terminal",
   "keywords": [
     "claude-code",