claude-code-kanban 7.7.0 → 7.9.0

package/lib/user-groups.js

@@ -1,24 +1,22 @@
 // User groups: named groups that hold projects and sessions, and may nest under another group.
 // The CLI and plugins change them one operation at a time; the board writes its copy whole with
 // `replace`. `groups` is one flat list; its order is the order of siblings. A member is in at
-// most one group.
+// most one group. A group that `dispatch start --group` had to make is transient: the board
+// removes it once its Active view shows none of its sessions, unless the user keeps it (clears
+// the flag).
 
 const { randomUUID } = require('node:crypto');
+const groupTree = require('../public/group-tree');
 const { httpError } = require('./http-error');
 const { oneLine } = require('./one-line');
 
-const MAX_GROUPS = 200;
+const MAX_GROUPS = 1000;
 const MAX_MEMBERS = 500;
-const MAX_RELEASED = 500;
 const MAX_DEPTH = 8;
 const MAX_NAME = 120;
 const MAX_REF = 4096;
 const ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
 const TYPES = new Set(['project', 'session']);
-// `group list` shows a dispatch group as `dispatch:<name>`; a key with it names the user group <name>,
-// which takes that dispatch group's sessions in.
-const DISPATCH_PREFIX = 'dispatch:';
-const dispatchName = (key) => (typeof key === 'string' && key.startsWith(DISPATCH_PREFIX) ? key.slice(DISPATCH_PREFIX.length) : null);
 
 const fail = (status, message) => {
   throw httpError(status, message);
@@ -42,16 +40,9 @@ const sameMember = (a, b) => a.type === b.type && a.ref === b.ref;
 const groupHolding = (groups, member) => groups.find((g) => g.members.some((m) => sameMember(m, member)));
 const groupsNamed = (groups, name) => groups.filter((g) => g.name.toLowerCase() === name.toLowerCase());
 
-// Where the board shows a session (sgGroupForSession in public/app.js): `held` is the user group
-// that holds it or its project. Else, unless released, `named` is a user group named like its
-// dispatch group, which takes it in, and with none `dispatch` is that dispatch group's name.
-function placeSession(groups, released, { ref, project, dispatchGroup }) {
-  const held = groupHolding(groups, { type: 'session', ref }) || (project && groupHolding(groups, { type: 'project', ref: project }));
-  if (held) return { held, named: null, dispatch: null };
-  const dispatch = dispatchGroup && !released.includes(ref) ? dispatchGroup : null;
-  const named = (dispatch && groupsNamed(groups, dispatch)[0]) || null;
-  return { held: null, named, dispatch: named ? null : dispatch };
-}
+// Where the board shows a session (sgGroupForSession in public/app.js).
+const sessionGroup = (groups, { ref, project }) =>
+  groupHolding(groups, { type: 'session', ref }) || (project && groupHolding(groups, { type: 'project', ref: project })) || null;
 
 function wouldCycle(list, id, parent) {
   let depth = 0;
@@ -76,7 +67,9 @@ function readGroups(list, taken = new Set()) {
       taken.add(memberKey(clean));
       members.push(clean);
     }
-    out.push({ id: g.id, name: cleanName(g.name) || 'Group', parent: typeof g.parent === 'string' ? g.parent : null, members });
+    const group = { id: g.id, name: cleanName(g.name) || 'Group', parent: typeof g.parent === 'string' ? g.parent : null, members };
+    if (g.transient === true) group.transient = true;
+    out.push(group);
   }
   for (const g of out) {
     if (g.parent && (!seen.has(g.parent) || g.parent === g.id)) g.parent = null;
@@ -85,8 +78,6 @@ function readGroups(list, taken = new Set()) {
   return out;
 }
 
-const readReleased = (list) => [...new Set((Array.isArray(list) ? list : []).filter(isRef))].slice(-MAX_RELEASED);
-
 /**
  * @param {object} o
  * @param {() => object|null|undefined} o.load `undefined` means keep what is in memory: the file has
@@ -95,7 +86,6 @@ const readReleased = (list) => [...new Set((Array.isArray(list) ? list : []).fil
  */
 function createUserGroupStore({ load, save, now = () => new Date().toISOString(), newId = randomUUID }) {
   let groups = [];
-  let released = [];
   let rev = 0;
   let migratedAt = null;
   // The last state read or saved. The changes edit `groups` in place, so a refused save puts it back.
@@ -105,7 +95,6 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
     rev = Number.isSafeInteger(data.rev) && data.rev >= 0 ? data.rev : 0;
     migratedAt = typeof data.groupsMigratedAt === 'string' ? data.groupsMigratedAt : null;
     groups = readGroups(data.groups);
-    released = readReleased(data.released);
   }
 
   // Another board on the same config dir writes the same file. Returns whether the rev moved.
@@ -124,7 +113,7 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
   const groupOf = (member) => groupHolding(groups, member);
   const byName = (name) => groupsNamed(groups, name);
 
-  const state = () => ({ version: 2, rev, groupsMigratedAt: migratedAt, groups, released });
+  const state = () => ({ version: 2, rev, groupsMigratedAt: migratedAt, groups });
 
   function commit() {
     rev++;
@@ -158,12 +147,13 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
     for (const g of groups) g.members = g.members.filter((m) => !keys.has(memberKey(m)));
   }
 
-  function addGroup({ id, name, parent = null, before = null, members = [] }) {
+  function addGroup({ id, name, parent = null, before = null, members = [], transient = false }) {
     if (groups.length >= MAX_GROUPS) fail(422, `at most ${MAX_GROUPS} groups`);
     if (id != null && (!ID_RE.test(id) || byId(id))) fail(400, 'id must be unique, 1-64 of [A-Za-z0-9_-]');
     const gid = id ?? newGroupId();
     const clean = readGroups([{ id: gid, members }])[0].members;
     const group = { id: gid, name: cleanName(name) || `Group ${groups.length + 1}`, parent: checkParent(gid, parent), members: clean };
+    if (transient) group.transient = true;
     detach(new Set(clean.map(memberKey)));
     groups.push(group);
     moveBefore(groups, group, before, (g, id) => g.id === id);
@@ -181,7 +171,8 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
     return names.join('/');
   };
 
-  // A path names a top-level group, then a child at each step. `make` adds the missing steps.
+  // A path names a top-level group, then a child at each step. `make` adds the missing steps, and
+  // `make.transient` marks the steps it adds.
   function findPath(path, make, hint) {
     const steps = path.split('/').map(cleanName);
     if (steps.some((s) => !s)) fail(400, `group path "${path}" has an empty step`);
@@ -192,7 +183,7 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
       const named = byName(step).filter((g) => g.parent === (parent?.id ?? null));
       if (named.length > 1) fail(400, `${named.length} groups are named "${pathOf(named[0])}"; pass one id: ${named.map((g) => g.id).join(', ')}`);
       if (named.length) parent = named[0];
-      else if (make) [parent, created] = [addGroup({ name: step, parent: parent?.id ?? null }), true];
+      else if (make) [parent, created] = [addGroup({ name: step, parent: parent?.id ?? null, transient: make.transient }), true];
       else return fail(404, `no group "${parent ? `${pathOf(parent)}/` : ''}${step}"; ${hint}`);
     }
     return { group: parent, created };
@@ -208,25 +199,24 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
     if (!named.length && key.includes('/')) return findPath(key, make, hint);
     if (named.length > 1) fail(400, `${named.length} groups are named "${name}"; pass one id: ${named.map((g) => g.id).join(', ')}`);
     if (named.length) return { group: named[0], created: false };
-    if (make) return { group: addGroup({ name }), created: true };
+    if (make) return { group: addGroup({ name, transient: make.transient }), created: true };
     const known = groups.map((g) => g.name).join(', ');
     return fail(404, `no group "${name}"${known ? ` (groups: ${known})` : ''}; ${hint}`);
   }
 
-  // The group the board shows `peer` in: its own placement, its project's, or a user group named
-  // like its dispatch group. A new group holds `peer` too.
+  // The group the board shows `peer` in: its own placement or its project's. A new group holds
+  // `peer` too.
   function peerGroup(peer, make) {
     const { ref, name } = peer;
-    const { held, named, dispatch } = placeSession(groups, released, peer);
-    const hit = held || named;
+    const hit = sessionGroup(groups, peer);
     if (hit) return { group: hit, created: false };
     if (!make) return fail(404, `session ${ref.slice(0, 8)} is in no group; pass --create to make one`);
-    return { group: addGroup({ name: dispatch || name, members: [{ type: 'session', ref }] }), created: true };
+    return { group: addGroup({ name, members: [{ type: 'session', ref }] }), created: true };
   }
 
   // A session placed with no `under` or `loose` shows in its project's block when the group holds
   // its project, else on the group's own level, as the board's context menu places it.
-  // `peer` ({ref, project, dispatchGroup, name}) puts the session in the group of that session.
+  // `peer` ({ref, project, name}) puts the session in the group of that session.
   // `parent` names the session the board shows it under; null clears it.
   function groupSession(ref, { group, peer, parent, create: make = false } = {}) {
     // Checked before findGroup, which may add the group.
@@ -237,19 +227,28 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
     if (peer) {
       if (!isRef(peer.ref) || peer.ref === ref) fail(400, 'the other session must be a different session');
     } else if (group == null) {
-      if (left === null && released.includes(ref)) return { group: null, left, ...state() };
-      return { group: null, left, ...ungroup({ ...member, release: true }) };
+      return { group: null, left, ...(left === null ? state() : ungroup(member)) };
     }
-    const dispatched = dispatchName(group);
-    const { group: hit, created } = peer ? peerGroup(peer, make) : findGroup(dispatched ?? group, make || dispatched !== null);
+    const { group: hit, created } = peer ? peerGroup(peer, make) : findGroup(group, make);
     return { ...groupRef(hit), created, left, ...place(hit.id, member) };
   }
 
+  // `dispatch start --group`: the started session joins the group, and the groups of the path
+  // that had to be made are transient.
+  function joinDispatch(key, ref) {
+    if (!isRef(ref)) fail(400, 'session id is required');
+    const { group } = findGroup(key, { transient: true });
+    const { rev: saved } = place(group.id, { type: 'session', ref });
+    return { ...groupRef(group), transient: !!group.transient, rev: saved };
+  }
+
+  // A renamed group is the user's: it stays after its sessions end.
   function update(id, { name, parent, before } = {}) {
     const group = mustGet(id);
     const nextName = name === undefined ? group.name : cleanName(name) || fail(400, 'name must be a non-empty string');
     const nextParent = parent === undefined ? group.parent : checkParent(id, parent);
     if (before != null && !byId(before)) fail(400, `no group ${before}`);
+    if (name !== undefined) delete group.transient;
     group.name = nextName;
     group.parent = nextParent;
     if (before !== undefined) moveBefore(groups, group, before, (g, id) => g.id === id);
@@ -266,13 +265,11 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
   const describe = (g) => ({ id: g.id, name: g.name, path: pathOf(g) });
   const groupRef = (g) => ({ group: g.id, name: g.name, path: pathOf(g) });
 
-  function userGroupByKey(key) {
-    if (dispatchName(key) !== null) fail(400, 'a dispatch group goes when its sessions end; `session ungroup` takes a session out');
-    return findGroup(key, false, 'see `group list`').group;
-  }
+  const userGroupByKey = (key) => findGroup(key, false, 'see `group list`').group;
 
-  function createPath(path) {
-    const { group, created } = findGroup(dispatchName(path) ?? path, true);
+  // `transient` marks the groups of the path that had to be made.
+  function createPath(path, transient = false) {
+    const { group, created } = findGroup(path, { transient });
     if (!created) fail(400, `group "${pathOf(group)}" exists (${group.id})`);
     return { ...groupRef(group), rev: commit().rev };
   }
@@ -290,14 +287,50 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
 
   // A parent that holds only empty groups goes with them.
   function prune({ dryRun = false, isLive }) {
-    const empty = (g) => !g.members.some(isLive) && groups.every((c) => c.parent !== g.id || empty(c));
-    const doomed = groups.filter(empty);
-    const removed = doomed.map(describe);
-    if (dryRun || !doomed.length) return { removed, dryRun, rev };
-    groups = groups.filter((g) => !doomed.includes(g));
+    const doomed = cascade((g) => !g.members.some(isLive));
+    const removed = groups.filter((g) => doomed.has(g)).map(describe);
+    if (dryRun || !doomed.size) return { removed, dryRun, rev };
+    groups = groups.filter((g) => !doomed.has(g));
     return { removed, dryRun, rev: commit().rev };
   }
 
+  const cascade = (goes) => groupTree.cascade(groups, goes);
+
+  const subtree = (g) => [g, ...groups.filter((c) => c.parent === g.id).flatMap(subtree)];
+  const isSession = (m) => m.type === 'session';
+
+  function dropSessions(scope, drop) {
+    const emptied = new Set();
+    let members = 0;
+    for (const g of scope) {
+      const kept = g.members.filter((m) => !isSession(m) || !drop(m));
+      if (kept.length === g.members.length) continue;
+      members += g.members.length - kept.length;
+      g.members = kept;
+      if (!kept.length) emptied.add(g);
+    }
+    return { members, emptied };
+  }
+
+  // A group that was empty before the sweep stays: the user may have made it to fill later.
+  function expire(isDead) {
+    const { members, emptied } = dropSessions(groups, isDead);
+    if (!members) return { members: 0, groups: 0, rev };
+    const gone = cascade((g) => emptied.has(g));
+    groups = groups.filter((g) => !gone.has(g));
+    return { members, groups: gone.size, rev: commit().rev };
+  }
+
+  // `groups` counts every group after the clean, so the caller can show them without asking again.
+  function clean({ group, dryRun = false, isVisible }) {
+    const scope = group == null ? groups : subtree(mustGet(group));
+    const hidden = (m) => isSession(m) && !isVisible(m);
+    const countHidden = (g) => g.members.filter(hidden).length;
+    const dropped = dryRun ? scope.reduce((n, g) => n + countHidden(g), 0) : dropSessions(scope, hidden).members;
+    const counts = groups.map((g) => ({ ...describe(g), members: g.members.length, hidden: countHidden(g) }));
+    return { groups: counts, dropped, dryRun, rev: dropped && !dryRun ? commit().rev : rev };
+  }
+
   // `supersede` names session members to drop with the move: the sessions of a project being
   // moved, which only the caller can list. With no `parent`, a move inside the group keeps it.
   function place(id, { type, ref, under, loose, parent, before = null, supersede = [] } = {}) {
@@ -312,41 +345,28 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
     return commit();
   }
 
-  function ungroup({ type, ref, release = false } = {}) {
+  function ungroup({ type, ref } = {}) {
     const member = cleanMember({ type, ref }) || fail(400, 'type must be project or session, with a ref');
     detach(new Set([memberKey(member)]));
-    if (release && type === 'session') addReleased([ref]);
-    return commit();
-  }
-
-  function addReleased(ids) {
-    released = readReleased([...released.filter((x) => !ids.includes(x)), ...ids]);
-  }
-
-  function release(ids) {
-    if (!Array.isArray(ids)) fail(400, 'ids must be an array');
-    addReleased(ids);
     return commit();
   }
 
   // The board edits its own copy and writes it whole; `rev` must be the one it last read.
-  function replace({ rev: base, groups: list, released: rel } = {}) {
+  function replace({ rev: base, groups: list } = {}) {
     if (base !== rev) fail(409, 'groups changed since rev; read them again');
     groups = readGroups(list);
-    released = readReleased(rel);
     return commit();
   }
 
   // The board's groups from before the server kept them. Only the first import is taken; a later
   // one changes nothing. A member the server already holds stays where it is.
-  function importLocal({ groups: list, released: rel } = {}) {
+  function importLocal({ groups: list } = {}) {
     if (migratedAt) return { imported: false, ...state() };
     const taken = new Set(groups.flatMap((g) => g.members.map(memberKey)));
     for (const g of readGroups(list, taken)) {
       if (groups.length >= MAX_GROUPS) break;
       groups.push({ ...g, id: byId(g.id) ? newGroupId() : g.id, parent: null });
     }
-    addReleased(readReleased(rel));
     migratedAt = now();
     return { imported: true, ...commit() };
   }
@@ -358,7 +378,7 @@ function createUserGroupStore({ load, save, now = () => new Date().toISOString()
     return id;
   }
 
-  return { state, reload, create, update, remove, place, ungroup, release, replace, importLocal, groupSession, createPath, rename, removeByKey, prune };
+  return { state, reload, create, update, remove, place, ungroup, replace, importLocal, groupSession, joinDispatch, createPath, rename, removeByKey, prune, expire, clean };
 }
 
-module.exports = { createUserGroupStore, placeSession, DISPATCH_PREFIX };
+module.exports = { createUserGroupStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "7.7.0",
+  "version": "7.9.0",
   "description": "A web-based Kanban board for viewing Claude Code tasks with agent teams support",
   "main": "server.js",
   "type": "commonjs",
@@ -11,6 +11,7 @@
     "start": "node server.js",
     "dev": "node --watch server.js",
     "test": "node --test test/*.test.js",
+    "test:swarm": "npm --prefix extensions/swarm/plugin/plugins/swarm test",
     "validate:schemas": "node test/validate-live-schemas.js",
     "prepare": "husky"
   },