claude-code-kanban 7.5.0 → 7.6.1

package/public/terminal-frame.js

@@ -313,8 +313,6 @@
           return open(m);
         case 'detach':
           return detach();
-        case 'send':
-          return send(m.msg);
         case 'theme':
           return applyTheme(m.options);
         case 'font':

package/public/tree-highlight.js

@@ -11,7 +11,8 @@ const treeHighlight = (() => {
     String.raw`^([+-](?=[ \t│├└▼]|$))?([ \t]*(?:[│├└─▼↓→ \t]*[│├└─▼↓→][ \t]*)?)(${NAME})?(.*)$`,
     'su',
   );
-  const INDENT_NODE_LINE = new RegExp(String.raw`^([ \t]*)${NAME}(\([^()]*\))?( {2,}\S.*)?$`, 'u');
+  const FRAME = new RegExp(String.raw`^( *)(~.*?|${NAME}(?:\([^()]*\))?)( \*)?(?:( {2,})(\S(?:.*\S)?))?( *)$`, 'u');
+  const LOC = /^[^\s:]+:\d+(?::\d+)?$/;
 
   function escapeText(s) {
     return s
@@ -36,25 +37,61 @@ const treeHighlight = (() => {
     return false;
   }
 
-  // A call tree drawn with indentation only: every line is one name or call, with an optional
-  // note after two spaces. Prose and pseudocode have single-spaced words, so they never match.
-  function looksLikeIndentTree(text, diff) {
-    const lines = text.split('\n').filter((l) => l.trim());
-    if (lines.length < 3) return false;
-    const indents = new Set();
-    for (const raw of lines) {
-      if (diff && !/^[ +-]/.test(raw)) return false;
-      const m = (diff ? raw.slice(1) : raw).match(INDENT_NODE_LINE);
-      if (!m) return false;
-      indents.add(m[1].length);
+  // The notation of skills/show/references/explain.md: frames indented by spaces, one name or
+  // call each, an optional ` *` focus mark, a note after 2+ spaces, `~` folds, and `+`/`-` in
+  // column 1 for a change. Prose and pseudocode have single-spaced words, so they never parse.
+  function parseStack(text) {
+    const lines = text.split('\n');
+    const diff = lines.some((l) => /^[+-]/.test(l));
+    const rows = [];
+    let roots = [];
+    let stack = [];
+    for (const line of lines) {
+      if (!line.trim()) {
+        rows.push({ blank: true, text: line });
+        roots = [];
+        stack = [];
+        continue;
+      }
+      const marker = diff ? line[0] : '';
+      if (diff && !/[ +-]/.test(marker)) return null;
+      const m = line.slice(marker.length).match(FRAME);
+      if (!m) return null;
+      const [, ind, label, star = '', gap = '', note = '', tail] = m;
+      while (stack.length && stack[stack.length - 1].indent >= ind.length) stack.pop();
+      const parent = stack[stack.length - 1] || null;
+      const sibs = parent ? parent.kids : roots;
+      const row = {
+        id: rows.length,
+        marker,
+        indent: ind.length,
+        parent,
+        sibs,
+        label,
+        fold: label.startsWith('~'),
+        star,
+        gap,
+        note,
+        tail,
+        kids: [],
+      };
+      sibs.push(row);
+      stack.push(row);
+      rows.push(row);
     }
-    return indents.size >= 2;
+    return rows;
+  }
+
+  // An untagged call tree: 3 frames at least, on 2 indent levels at least.
+  function looksLikeIndentTree(text) {
+    const frames = parseStack(text)?.filter((r) => !r.blank) || [];
+    return frames.length >= 3 && new Set(frames.map((r) => r.indent)).size >= 2;
   }
 
   function wantsTree(lang, text) {
     const tag = (lang || '').trim().toLowerCase();
     if (TREE_TAGS.has(tag)) return true;
-    return PLAIN_TAGS.has(tag) && (looksLikeTree(text) || looksLikeIndentTree(text, tag === 'diff'));
+    return PLAIN_TAGS.has(tag) && (looksLikeTree(text) || looksLikeIndentTree(text));
   }
 
   function highlightLine(line) {
@@ -68,7 +105,92 @@ const treeHighlight = (() => {
     return text.split('\n').map(highlightLine).join('\n');
   }
 
-  return { wantsTree, highlightTree };
+  const isLast = (row) => row.sibs[row.sibs.length - 1] === row;
+
+  function guideCells(row) {
+    const g = Array(row.indent).fill('');
+    if (row.parent) {
+      for (let a = row.parent; a.parent; a = a.parent) if (!isLast(a)) g[a.parent.indent] = 'v';
+      g[row.parent.indent] = isLast(row) ? 'l' : 't';
+      if (row.parent.indent + 1 < row.indent) g[row.parent.indent + 1] = 'h';
+    }
+    return g.map((c) => (c ? `<span class="ct-g ct-${c}"> </span>` : ' ')).join('');
+  }
+
+  function renderRow(row) {
+    if (row.blank) return `<span class="ct-row">${row.text}</span>`;
+    const cls = ['ct-row'];
+    if (row.star) cls.push('ct-focus');
+    if (row.marker === '+') cls.push('ct-add');
+    if (row.marker === '-') cls.push('ct-del');
+    const above = [];
+    for (let a = row.parent; a; a = a.parent) above.push(a);
+    if (above.some((a) => !a.open)) cls.push('ct-hidden');
+    if (above.some((a) => a.fold)) cls.push('ct-lib');
+    let attrs = above.length ? ` data-ct-in="${above.map((a) => a.id).join(' ')}"` : '';
+    let label;
+    if (row.fold) {
+      cls.push('ct-fold');
+      label = `<span class="ct-tilde">~</span>${escapeText(row.label.slice(1))}`;
+    } else {
+      label = span('ct-name', row.label);
+    }
+    if (row.kids.length) {
+      cls.push('ct-has');
+      attrs += ` data-ct="${row.id}" role="button" tabindex="0" aria-expanded="${row.open}"`;
+    }
+    return (
+      `<span class="${cls.join(' ')}"${attrs}>` +
+      span('ct-m', row.marker) +
+      guideCells(row) +
+      label +
+      span('ct-star', row.star) +
+      row.gap +
+      span(LOC.test(row.note) ? 'ct-loc' : 'ct-note', row.note) +
+      row.tail +
+      '</span>'
+    );
+  }
+
+  // Rows are blocks, so the newlines between them sit in hidden spans: the text stays
+  // byte-identical and the rows draw no blank lines.
+  function renderTree(text) {
+    const rows = parseStack(text);
+    if (!rows) return `<pre><code class="hljs language-tree">${highlightTree(text)}</code></pre>`;
+    for (let i = rows.length - 1; i >= 0; i--) {
+      const r = rows[i];
+      if (r.parent && (r.star || r.marker === '+' || r.marker === '-' || r.holdsPoint)) r.parent.holdsPoint = true;
+    }
+    for (const r of rows) r.open = !r.fold || !!r.holdsPoint;
+    return `<pre><code class="hljs ct">${rows.map(renderRow).join('<span class="ct-nl">\n</span>')}</code></pre>`;
+  }
+
+  function toggleFold(fold) {
+    fold.setAttribute('aria-expanded', String(fold.getAttribute('aria-expanded') !== 'true'));
+    const code = fold.closest('code');
+    const closed = new Set();
+    for (const f of code.querySelectorAll('.ct-has[aria-expanded="false"]')) closed.add(f.dataset.ct);
+    for (const r of code.querySelectorAll('[data-ct-in]')) {
+      r.classList.toggle(
+        'ct-hidden',
+        r.dataset.ctIn.split(' ').some((id) => closed.has(id)),
+      );
+    }
+  }
+
+  // A note in the LOC form → { path, line }, else null.
+  function parseLoc(text) {
+    if (!LOC.test(text)) return null;
+    const [path, line] = text.split(':');
+    return { path, line: Math.max(1, Number(line)) };
+  }
+
+  // A trailing newline does not start a line.
+  function lineCount(text) {
+    return Math.max(1, text.split('\n').length - (text.endsWith('\n') ? 1 : 0));
+  }
+
+  return { wantsTree, highlightTree, renderTree, toggleFold, parseLoc, lineCount };
 })();
 
 if (typeof module === 'object' && module.exports) module.exports = treeHighlight;

package/server.js

@@ -28,6 +28,7 @@ const {
   modelDisplayName,
   buildSessionDigest,
   readCompactSummaries,
+  fillCompactSummaries,
   readArtifactLinks,
   readScratchpadCreations,
   extractPromptFromTranscript,
@@ -48,9 +49,9 @@ const { buildDecision, decisionFileName, isDecisionFile, approvalsFrom, boardRef
 const { getClaudeDir, getArgValue, storageNamespace, isDefaultClaudeDir } = require('./lib/claude-dir');
 const { readTerminalConfig } = require('./lib/terminal');
 const { createTerminalClient } = require('./lib/terminal-client');
+const { createShowStore, mountShowRoutes, showBodyParser, SHOW_PATH } = require('./lib/show');
 const { readLiveSessions, isPidAlive, isSessionLive } = require('./lib/live-sessions');
 const { createProcStats } = require('./lib/proc-stats');
-const { createDispatchRegistry } = require('./lib/dispatch');
 const { createGroupStore, isGroupName, suggestGroupName } = require('./lib/dispatch-groups');
 const { createDispatchedStore, scanTranscripts, pruneSessionDirs, pruneContextStatus, pruneTaskMaps, retentionMs } = require('./lib/retention');
 const { freshRateLimits } = require('./lib/rate-limits');
@@ -660,6 +661,7 @@ app.param('name', (_req, res, next, val) => {
   next();
 });
 
+app.use(SHOW_PATH, showBodyParser());
 // Parse JSON bodies. A review of 50 comments at the field caps is about 450 kB.
 app.use(express.json({ limit: '1mb' }));
 // #endregion
@@ -3045,7 +3047,10 @@ async function sendSessionMessages(req, res) {
     hasMore = messages.length > limit;
     if (hasMore) messages = messages.slice(-limit);
   }
-  const compactPromise = cachedByMtime(compactSummaryCache, jsonlPath, jsonlPath, () => readCompactSummaries(jsonlPath), []);
+  const compactedMsgs = messages.filter(m => m.systemLabel === 'Compacted');
+  const compactPromise = compactedMsgs.some(m => !m.compactSummary)
+    ? cachedByMtime(compactSummaryCache, jsonlPath, jsonlPath, () => readCompactSummaries(jsonlPath), [])
+    : null;
   const agentMessages = messages.filter(m => m.tool === 'Agent' && m.toolUseId);
   if (agentMessages.length) {
     const progressMap = await getProgressMap(jsonlPath);
@@ -3099,16 +3104,7 @@ async function sendSessionMessages(req, res) {
       }
     }
   }
-  const compactSummaries = await compactPromise;
-  // Match compaction messages to summaries by chronological order
-  const compactedMsgs = messages
-    .filter(m => m.systemLabel === 'Compacted')
-    .sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
-  for (let i = 0; i < compactedMsgs.length; i++) {
-    if (i < compactSummaries.length) {
-      compactedMsgs[i].compactSummary = compactSummaries[i].summary;
-    }
-  }
+  if (compactPromise) fillCompactSummaries(compactedMsgs, await compactPromise);
   // The client keeps needing toolUseId when it builds a follow-up URL from it:
   // lazy-fetching a truncated tool result, or fetching each tool-result image.
   const clientNeedsToolUseId = (msg) => msg.toolResultTruncated || msg.toolResultImageCount;
@@ -3321,6 +3317,16 @@ function resolveSessionFolder(id) {
   return meta ? meta.project || meta.cwd || null : null;
 }
 
+// The host saves its terminals; cck adds the show map (terminal id → session id) beside them.
+const terminalsFile = jsonFile(TERMINALS_FILE);
+let savedTerminals = terminalsFile.load() || {};
+
+function saveTerminals() {
+  const kept = new Set(Object.values(savedTerminals.terminalIds || {}));
+  const showSessions = show.prune((id) => kept.has(id) || terminal.hasTerminal(id));
+  terminalsFile.save({ ...savedTerminals, showSessions });
+}
+
 const terminal = createTerminalClient({
   config: readTerminalConfig({ getArgValue }),
   net,
@@ -3328,14 +3334,18 @@ const terminal = createTerminalClient({
   isDefaultDir: isDefaultClaudeDir(CLAUDE_DIR),
   sessionsDir: SESSIONS_DIR,
   token: process.env.CCK_TERMINAL_TOKEN,
-  ...jsonFile(TERMINALS_FILE),
+  load: terminalsFile.load,
+  save: (data) => {
+    savedTerminals = data;
+    saveTerminals();
+  },
   // The project, not the last cwd: `claude --resume` finds a session under the
   // project dir it started in, and cwd drifts into subdirectories.
   resolveCwd: resolveSessionFolder,
   isAllowedFolder,
   onChange: () => broadcast({ type: 'terminals-update', ids: terminal.ids() }),
   onExit: (id) => {
-    if (dispatches.remove(id)) broadcast({ type: 'dispatch-update' });
+    if (dispatched.get(id)) broadcast({ type: 'dispatch-update' });
   },
 });
 
@@ -3396,6 +3406,25 @@ app.delete('/api/terminals/:id', terminalRoute(async (req, res) => {
   res.status(204).end();
 }));
 
+const show = createShowStore({
+  load: () => savedTerminals.showSessions,
+  onChange: saveTerminals,
+  onPosted: (e) => broadcast({ type: 'show:posted', ...e }),
+  startedSession: terminal.sessionOfTerminal,
+  resolveDir: (id) => {
+    const meta = sessionMetaFor(id);
+    return meta ? getScratchpadDir(id, meta) : null;
+  },
+});
+mountShowRoutes(app, {
+  store: show,
+  authorized: (token) => terminal.authorized(token),
+  hasTerminal: (id) => terminal.hasTerminal(id),
+  readPreviewFile,
+  broadcast,
+  onRemoved: (sessionId, paths) => panes.removeShow(sessionId, paths),
+});
+
 // Served from node_modules, never a CDN: any script on this page can use the token.
 const XTERM_FILES = {
   'xterm.js': '@xterm/xterm/lib/xterm.js',
@@ -3417,8 +3446,6 @@ app.get('/vendor/xterm/:file', (req, res) => {
 // #region DISPATCH
 const dispatched = createDispatchedStore(jsonFile(DISPATCHED_FILE));
 
-const dispatches = createDispatchRegistry();
-
 const dispatchGroups = createGroupStore({
   ...jsonFile(DISPATCH_GROUPS_FILE),
   isAlive: (id) => terminal.isRunning(id) || isSessionLive(loadLiveSessions(), id),
@@ -3454,8 +3481,7 @@ app.post('/api/dispatch', terminalRoute(async (req, res) => {
   }
   const started = await terminal.startNew({ cwd, name, model, worktree, taskList, prompt: spec.trim(), extraArgs: claudeArgs });
   if (started.error) return res.status(started.status).json({ error: started.error });
-  dispatches.add({ session: started.id, parent, cwd: started.cwd, name, group: group || null, worktree });
-  dispatched.record(started.id, parent);
+  dispatched.record(started.id, { parent, cwd: started.cwd, name, group, worktree });
   // The starter stays where it is: moving it would jump it under the user.
   if (group) dispatchGroups.join(group, [started.id]);
   broadcast({ type: 'dispatch-update' });
@@ -3465,7 +3491,7 @@ app.post('/api/dispatch', terminalRoute(async (req, res) => {
 app.get('/api/dispatch', (req, res) => {
   res.setHeader('Cache-Control', 'no-store');
   const parent = typeof req.query.parent === 'string' && req.query.parent ? req.query.parent : null;
-  res.json({ running: dispatches.list({ parent }) });
+  res.json({ running: dispatched.running(terminal.isRunning, { parent }) });
 });
 // #endregion
 
@@ -3524,7 +3550,8 @@ const {
   formatReviewSubmitted,
   formatTaskMoved,
   handleSessionEvents,
-  hasSessionListener,
+  hasDoorbell,
+  configureSessionEvents,
 } = require('./lib/session-events');
 app.get('/api/sessions/:sessionId/events', handleSessionEvents);
 
@@ -4092,11 +4119,11 @@ app.get('/api/panes/:sessionId', (req, res) => {
 
 app.post('/api/panes/:sessionId', async (req, res) => {
   try {
-    const { target, base, title, kind } = req.body || {};
+    const { target, base, title, kind, show } = req.body || {};
     if (typeof target !== 'string' || !target) throw previewError(400, 'target is required', 'bad_target');
     // A message target is a session log message id, which the board resolves when it shows the pane.
     const resolved = kind === 'message' ? { kind, target } : await resolvePaneTarget(target, base);
-    res.json(panes.add(req.params.sessionId, { ...resolved, title }));
+    res.json(panes.add(req.params.sessionId, { ...resolved, title, show: show === true }));
   } catch (error) {
     paneRouteError(res, error, 'POST /api/panes');
   }
@@ -4159,6 +4186,23 @@ app.delete('/api/panes/:sessionId/:paneId', (req, res) => {
 // carries one line, and the file is what each route points at.
 const REVIEW_DIR = path.join(CCK_DIR, 'reviews');
 const REVIEW_KIND_RE = /^[a-z]{1,20}$/;
+
+// `<ts>.pending` holds the doorbell line of a review the mod has not acked yet.
+configureSessionEvents({
+  onDelivered: (entry) => fs.unlink(entry.marker).catch(() => {}),
+  restore: async (sessionId) => {
+    if (!isUUID(sessionId)) return [];
+    const dir = path.join(REVIEW_DIR, sessionId);
+    const names = (await fs.readdir(dir).catch(() => [])).filter((n) => n.endsWith('.pending')).sort();
+    const lines = [];
+    for (const name of names) {
+      const marker = path.join(dir, name);
+      const text = await fs.readFile(marker, 'utf8').catch(() => '');
+      if (text) lines.push({ text, marker });
+    }
+    return lines;
+  },
+});
 const REVIEW_MAX_COMMENTS = 50;
 const REVIEW_MAX_CHARS = 4000;
 
@@ -4227,8 +4271,11 @@ app.post('/api/sessions/:sessionId/review', async (req, res) => {
     await fs.writeFile(file, markdown);
 
     let delivered = null;
-    if (boardEventsEnabled() && hasSessionListener(sessionId)) {
-      enqueueSessionEvent(sessionId, formatReviewSubmitted(src.items.length, src.label, file));
+    if (boardEventsEnabled() && hasDoorbell(sessionId)) {
+      const line = formatReviewSubmitted(src.items.length, src.label, file);
+      const marker = file.replace(/\.md$/, '.pending');
+      await fs.writeFile(marker, line);
+      enqueueSessionEvent(sessionId, line, { marker });
       delivered = 'doorbell';
     } else if (
       terminal.authorized(req.get('x-terminal-token')) &&

package/lib/dispatch.js

@@ -1,32 +0,0 @@
-// Dispatch: a Claude Code session one session started in cck's terminal. In memory on
-// purpose: an entry lives as long as its PTY, which dies with the server.
-
-function createDispatchRegistry({ now = Date.now } = {}) {
-  const entries = new Map();
-
-  function add({ session, parent, cwd, name, group, worktree }) {
-    entries.set(session, {
-      session,
-      parent: parent || null,
-      cwd,
-      name: name || null,
-      group: group || null,
-      worktree: worktree || null,
-      startedAt: now(),
-    });
-  }
-
-  function list({ parent } = {}) {
-    const out = [...entries.values()];
-    return parent ? out.filter((e) => e.parent === parent) : out;
-  }
-
-  return {
-    add,
-    list,
-    has: (session) => entries.has(session),
-    remove: (session) => entries.delete(session),
-  };
-}
-
-module.exports = { createDispatchRegistry };