cawdev-cli 1.0.9-beta → 1.0.11-beta

package/runner/split.mjs

@@ -168,6 +168,38 @@ export function tailOf(lines, width, rows) {
   return out.reverse();
 }
 
+/**
+ * The reader — `/view` on a session waiting for an answer or a permission.
+ *
+ * A window's body is the TAIL of what was said and a question's banner fits
+ * the prompt's rows, so a long plan or a long question was cut and could not
+ * be scrolled. The reader is one window over the whole screen, showing
+ * `lines` from row `top` (wrapped to its width), with where it is in the
+ * title. `top` null means "start where the request starts" (`requestAt`);
+ * whatever is asked for is clamped, and the answer says what was used so the
+ * keys can page from it.
+ */
+export function readerFrame(width, height, { title = '', lines = [], requestAt = 0, top = null, footer = '' }, ink) {
+  const inner = Math.max(1, width - 2);
+  const rows = [];
+  let requestRow = 0;
+  lines.forEach((line, i) => {
+    if (i === requestAt) requestRow = rows.length;
+    rows.push(...wrap(String(line ?? ''), inner));
+  });
+  const room = Math.max(1, height - 2 - (footer ? 1 : 0));
+  const max = Math.max(0, rows.length - room);
+  const at = Math.min(Math.max(0, top ?? requestRow), max);
+  const shown = rows.slice(at, at + room);
+  const where = rows.length > room ? ` · ${at + 1}–${at + shown.length} of ${rows.length}` : '';
+  return {
+    lines: windowLines({ width, height }, { title: `${title}${where}`, body: shown, footer, focused: true }, ink),
+    top: at,
+    max,
+    room,
+  };
+}
+
 /**
  * The whole screen, from placed pieces: `height` rows, each the pieces that
  * cross it laid left to right, and blank where nothing is.
@@ -629,14 +661,31 @@ export function wordWrap(text, width) {
  * terminal acts on. MERGED, SHIPPED and DECLINED are not columns: the work
  * is over, the three only grow, and the console's own board folds the last
  * two to a count (R68) for the same reason — so here all three are counts
- * beside the project's name.
+ * beside the project's name. BACKLOG is a count too, at the head of them: it
+ * is work not yet taken up rather than work over, but a column of it would be
+ * the first to give way, and since R371 it is where a new issue lands — left
+ * out, a project's fresh bugs were on no line of the strip at all.
  */
 export const BOARD_COLUMNS = [
   ['CONSIDERING', 'Considering'],
   ['PLANNED', 'Planned'],
   ['IN_DEVELOPMENT', 'In development'],
 ];
-const FOLDED = [['MERGED', 'merged'], ['SHIPPED', 'shipped'], ['DECLINED', 'declined']];
+const FOLDED = [['BACKLOG', 'backlog'], ['MERGED', 'merged'], ['SHIPPED', 'shipped'], ['DECLINED', 'declined']];
+
+/**
+ * The column a card is drawn in. An issue (R85) has statuses of its own for
+ * the first two steps — NEW is reported and not yet agreed, CONFIRMED is
+ * agreed and waiting for somebody, the platform's `afterPlanning` — and they
+ * are Considering's and Planned's counterparts, so they share those columns
+ * rather than adding two more to a strip that already gives columns away.
+ */
+export function columnOf(status) {
+  return { NEW: 'CONSIDERING', CONFIRMED: 'PLANNED' }[status] ?? status;
+}
+
+/** Most broken first: the issues board's own order (R85), and what a column cut short keeps. */
+const SEVERITY_ORDER = ['CRITICAL', 'MEDIUM', 'MINOR'];
 
 /**
  * Which column gives way first when the width runs out: the ideas, then what
@@ -669,7 +718,12 @@ const STRIP_HEAD = 2;
  * column needs, no more — of exactly `width` columns. One line when there is
  * no project at all.
  *
- * @param cards `[{ ref, title, slug, status, live? }]`
+ * ISSUES SHARE THE COLUMNS (`columnOf`) and go first in each, most severe
+ * first: a column cut to `+N more` should not hide a critical defect under
+ * ideas. Their ref (`i12`) is in the colour of their severity.
+ *
+ * @param cards `[{ ref, title, slug, status, live?, severity? }]` — a card
+ *   with a `severity` is an issue
  * @param projects the slugs to show, in order; defaults to those the cards
  *   come from
  */
@@ -684,7 +738,7 @@ export function roadmapStrip(width, maxRows, cards, ink, projects = null) {
       slug,
       folded: FOLDED.map(([status, word]) => [word, mine.filter((c) => c.status === status).length]),
       columns: BOARD_COLUMNS.map(([status, label]) => ({
-        status, label, cards: mine.filter((card) => card.status === status),
+        status, label, cards: inColumn(mine, status),
       })),
       hidden: [],
     };
@@ -764,7 +818,7 @@ export function roadmapStrip(width, maxRows, cards, ink, projects = null) {
       } else if (column.cards[row]) {
         const card = column.cards[row];
         const mark = card.live ? ink.accent('●') : ' ';
-        cell = `${mark}${ink.bold(card.ref)} ${card.title ?? ''}`;
+        cell = `${mark}${refInk(card, ink)(card.ref)} ${card.title ?? ''}`;
       } else if (row === 0 && !column.cards.length) {
         cell = ink.muted(' —');
       }
@@ -774,6 +828,24 @@ export function roadmapStrip(width, maxRows, cards, ink, projects = null) {
   return lines.map((line) => padVisible(clip(line, width), width));
 }
 
+/** A column's cards: its issues first, most severe first, then its roadmap cards, each in the order given. */
+function inColumn(cards, status) {
+  const here = cards.filter((card) => columnOf(card.status) === status);
+  const rank = (card) => {
+    const at = SEVERITY_ORDER.indexOf(card.severity);
+    return at === -1 ? SEVERITY_ORDER.length : at;
+  };
+  const issues = here.filter((card) => card.severity).sort((a, b) => rank(a) - rank(b));
+  return [...issues, ...here.filter((card) => !card.severity)];
+}
+
+/** A card's ref in bold; an issue's in the colour of how broken it is. */
+function refInk(card, ink) {
+  if (!card.severity) return ink.bold;
+  const hue = card.severity === 'CRITICAL' ? ink.danger : card.severity === 'MEDIUM' ? ink.warn : ink.muted;
+  return (text) => ink.bold(hue(text));
+}
+
 /** Clipped to `width`, with `…` where it had to stop — a title cut dead reads as the whole title. */
 function ellipsed(text, width) {
   return visibleWidth(text) <= width ? text : `${clip(text, width - 1)}…`;

package/runner/workspace-check.mjs

@@ -0,0 +1,78 @@
+import { existsSync, statSync } from 'node:fs';
+import { access, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+
+/**
+ * Whether a workspace folder can be used at all, and how to say so — R377.
+ *
+ * Node reports a missing `cwd` as `spawn claude ENOENT`, which reads as "the
+ * agent CLI is not installed" and sends a person looking at their PATH. The
+ * folder is checked before it gets that far, and said in its own words.
+ *
+ * `.git` is checked with `access`, never `isDirectory()`: in a worktree —
+ * including the `-read` copy — it is a file.
+ */
+export async function workspaceProblem(path) {
+  try {
+    const found = await stat(path);
+    if (!found.isDirectory()) return { kind: 'not-a-directory', path };
+  } catch (failure) {
+    // ENOTDIR: a parent of it is a file, so it is no more there than if absent.
+    if (failure.code === 'ENOENT' || failure.code === 'ENOTDIR') return { kind: 'missing', path };
+    return { kind: 'unreadable', path, code: failure.code };
+  }
+  try {
+    await access(join(path, '.git'));
+  } catch {
+    return { kind: 'not-git', path };
+  }
+  return null;
+}
+
+/**
+ * The sentence for a problem. `first` is the project's `workspaces[0]`.
+ * The wording must not change from one poll to the next: `noteQueued` only
+ * logs again when the text does.
+ */
+export function workspaceProblemSaid(slug, problem, { first = null } = {}) {
+  const { kind, path } = problem;
+  if (kind === 'missing') {
+    const base = `${slug}'s workspace ${path} does not exist on this machine. `
+      + 'Clone the repository there, or correct "workspaces" with `cawdev config`.';
+    // `createAutoWorkspace` clones FROM the first workspace, so the advice
+    // cannot help when that is the one that is missing.
+    return path !== first
+      ? `${base} Or remove it and set "autoWorkspaces" so the runner clones checkouts beside ${first} itself.`
+      : base;
+  }
+  if (kind === 'not-a-directory') {
+    return `${slug}'s workspace ${path} is a file, not a folder. `
+      + 'Correct "workspaces" with `cawdev config`.';
+  }
+  if (kind === 'unreadable') {
+    return `${slug}'s workspace ${path} cannot be read (${problem.code ?? 'unknown error'}). `
+      + 'Fix its permissions, or correct "workspaces" with `cawdev config`.';
+  }
+  return `${slug}'s workspace ${path} exists but is not a git checkout (no .git in it). `
+    + 'Clone the repository there, or correct "workspaces" with `cawdev config`.';
+}
+
+function problemSync(cwd) {
+  if (!cwd || !existsSync(cwd)) return { kind: 'missing', path: cwd };
+  if (!statSync(cwd).isDirectory()) return { kind: 'not-a-directory', path: cwd };
+  return null;
+}
+
+/**
+ * What to tell a person when `spawn` fails. Runs inside an `'error'` handler,
+ * hence the synchronous checks. `label` is "the agent", "Antigravity" or "Codex".
+ */
+export function spawnFailureSaid({ failure, command, cwd, slug, label, first = null }) {
+  if (failure?.code === 'ENOENT') {
+    const problem = problemSync(cwd);
+    if (problem) return workspaceProblemSaid(slug, problem, { first });
+    return `\`${command}\` not found on this runner's PATH — set "agentCommands" to its full path `
+      + `(run \`which ${command}\` where it works).`;
+  }
+  return `Could not spawn ${label}: ${failure?.message}`;
+}