@ersbeth/codelife 0.0.0-stage → 0.11.1

package/scripts/target/templates/playground/main.ts

@@ -0,0 +1,9 @@
+// generated by codelife — maintained by hand
+//
+// The playground is where an example lives once it stops being dead code in a README. Import the
+// library by its package name: `tsconfig.json`'s `paths` send that to `src/`, so an edit to the source shows up
+// here on the next reload.
+import * as lib from '<package-name>'
+
+const out = document.querySelector('#out')
+if (out) out.textContent = Object.keys(lib).sort().join('\n')

package/scripts/target/templates/spec/README.md

@@ -0,0 +1,35 @@
+<!-- generated by codelife — /brainstorm -->
+# {{project}} — the specification
+
+{{The vision, in a few sentences: the problem the product solves, for whom, and what it
+deliberately does not do.}}
+
+What the system must do, and nothing about what is done: what is implemented is the code, and what
+remains is the open issues citing an identifier. A decision still waiting to be specified is a note
+in `docs/brainstorm/`. This file is the only index: a domain has no README, its card is the
+paragraph under its heading here.
+
+## Users
+
+[`users.md`](users.md) — who the product is for, one `P-<n>` per persona.
+
+## Journeys
+
+{{One line per journey, first priority first:
+`- [J-{{n}} — <journey>](journeys/<slug>.md) — <the goal, in one sentence>`.}}
+
+## Product
+
+{{One `###` per domain — a **user activity**, never a component — then its card in one paragraph,
+then one line per capability:
+`- [K-{{n}} — <capability>](product/<activity>/<slug>.md) — <what it lets the user do>`.}}
+
+## System
+
+{{One `###` per domain — a **component** — its card, then one line per capability:
+`- [K-{{n}} — <capability>](system/<component>/<slug>.md) — <what it provides>`.}}
+
+## Glossary and principles
+
+[`glossary.md`](glossary.md) — the terms, and the synonyms to avoid.
+[`principles.md`](principles.md) — what the product must respect.

package/scripts/target/templates/spec/capability.md

@@ -0,0 +1,36 @@
+<!-- generated by codelife — /brainstorm -->
+# K-{{n}} — {{capability}}
+
+## What it is for, and for whom
+
+{{The need it answers and its client — a persona, or the code that calls it.}}
+
+## Behaviour
+
+### R-{{n}} — {{the rule, as one observable sentence}}
+
+{{Free prose, in the present tense, with a "because" clause where the rule would look arbitrary.}}
+
+#### C-{{n}} — {{the case}}
+
+Given {{the situation}}
+When {{what is done}}
+Then {{what is observed}}
+
+## Internal design
+
+{{The mechanism, in the present tense: the data, the steps, the choices a reader of the code cannot
+recover alone — and the system capabilities it uses, each cited `K-{{n}} — <its heading>`. Empty
+for a capability with no algorithm.}}
+
+## What stays open
+
+{{The questions no decision has answered yet, each with what would settle it.}}
+
+## Rejected
+
+{{One line per rejected option, as the note wrote it, opening on the address it concerns — the
+identifier alone for a rule or a case, `- R-{{n}} — <option> — <cost> — <date>`, and
+`- § <heading> — <option> — <cost> — <date>` for what carries none. A former state that was
+replaced is such a line, "in force <from> → <to>", and a retired rule or case keeps its identifier
+there, so its number is never assigned again.}}

package/scripts/target/templates/spec/glossary.md

@@ -0,0 +1,5 @@
+<!-- generated by codelife — /brainstorm -->
+# Glossary
+
+{{One entry per term, in alphabetical order:
+`- **<term>** — <its definition> — avoid: <the synonyms not to use>`.}}

package/scripts/target/templates/spec/journey.md

@@ -0,0 +1,29 @@
+<!-- generated by codelife — /brainstorm -->
+# J-{{n}} — {{journey}}
+
+**Persona.** {{`P-{{n}} — <persona>`.}}
+**Priority.** {{First, second, … — the first-priority journeys define the minimum product.}}
+**Goal.** {{What the persona has achieved when the journey ends.}}
+**Independent test.** {{How someone who did not build it checks that the goal is reached.}}
+
+## Steps
+
+{{Numbered steps, each pointing at the case it walks and specifying nothing itself:
+`1. <what the persona does> — C-{{n}} — <its heading>`.}}
+
+## Success criteria
+
+{{What is measured, and the value that counts as success.}}
+
+## Out of this journey
+
+{{What a reader might expect here and belongs to another journey, named.}}
+
+## What stays open
+
+{{The questions no decision has answered yet, each with what would settle it.}}
+
+## Rejected
+
+{{One line per rejected option, opening on the address it concerns: `- J-{{n}} — <option> —
+<cost> — <date>` for what carries an identifier, `- § <heading> — …` for what carries none.}}

package/scripts/target/templates/spec/principles.md

@@ -0,0 +1,15 @@
+<!-- generated by codelife — /brainstorm -->
+# Principles
+
+{{What the product must respect — units, tolerances, budgets, platforms — one `##` per principle,
+cited as `principles.md § <heading>`. How one works in the repository is `CLAUDE.md`'s, not this
+file's.}}
+
+## What stays open
+
+{{The questions no decision has answered yet, each with what would settle it.}}
+
+## Rejected
+
+{{One line per refusal that concerns no capability — "no CI" is the refusal of a principle:
+`- § <heading> — <option> — <cost> — <date>`.}}

package/scripts/target/templates/spec/users.md

@@ -0,0 +1,15 @@
+<!-- generated by codelife — /brainstorm -->
+# Users
+
+## P-{{n}} — {{persona}}
+
+{{Who they are; their context of use; what they come to do; what they are not.}}
+
+## What stays open
+
+{{The questions no decision has answered yet, each with what would settle it.}}
+
+## Rejected
+
+{{One line per rejected option, opening on the address it concerns: `- P-{{n}} — <option> —
+<cost> — <date>` for what carries an identifier, `- § <heading> — …` for what carries none.}}

package/scripts/target/templates/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@ersbeth/codelife/presets/tsconfig.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "paths": { "<package-name>": ["./src/index.ts"] }
+  },
+  "include": ["src", "test", "playground", "vite.config.ts"]
+}

package/scripts/target/templates/vite.config.ts

@@ -0,0 +1,4 @@
+import { defineConfig, mergeConfig } from 'vite-plus'
+import { library } from '@ersbeth/codelife/presets/vite.config.mjs'
+
+export default defineConfig(mergeConfig(library({ entry: ['src/index.ts'] }), {}))

package/scripts/text.mjs

@@ -0,0 +1,6 @@
+// lf <text> — the text with every line ending in `\n` alone. A file checked out on Windows, or a body
+// a forge's web editor saved, ends its lines in `\r\n`, which a reader splitting on `\n` and matching
+// `^…$` misreads (#1124): what a script parses, it reads through this first.
+import './node-floor.mjs'
+
+export const lf = (text) => text.replace(/\r\n?/g, '\n')

package/scripts/tracker/account.mjs

@@ -0,0 +1,5 @@
+// tracker.account(host): the authenticated account's name.
+import { cli, origin, run } from './lib.mjs';
+
+console.log(cli() === 'glab' ? JSON.parse(run(['api', 'user', '--hostname', origin().host])).username
+  : run(['api', 'user', '--jq', '.login']).trim());

package/scripts/tracker/auth.mjs

@@ -0,0 +1,9 @@
+// tracker.auth(host): one line — `connected, expires <date>`, `connected, expiry unavailable`,
+// `expired` or `not connected: <the CLI's words>` — exit 0 only when connected. The host defaults to
+// origin's, the CLI is the contract's; the reading is scripts/setup/lib.mjs's `auth`, /setup's own.
+import { cli, origin } from './lib.mjs';
+import { auth } from '../setup/lib.mjs';
+
+const a = auth(cli(), process.argv[2] || origin().host);
+console.log(a.line);
+process.exit(a.connected ? 0 : 1);

package/scripts/tracker/cli.version.mjs

@@ -0,0 +1,5 @@
+// tracker.cli.version(): `<cli> <version>`, the forge CLI's own; the caller judges it against the floor.
+import { cli, die, run } from './lib.mjs';
+
+const version = run(['--version']).match(/\d+(\.\d+)+/)?.[0] || die('the CLI printed no version');
+console.log(`${cli()} ${version}`);

package/scripts/tracker/close.mjs

@@ -0,0 +1,20 @@
+// tracker.close(n, closing fields, wontfix?): the comment, read from its file, then the close, then with
+// `wontfix` the label — in that order, so a close cut midway
+// leaves the reasoning and never a silently closed issue. `node close.mjs <n> <comment file> [wontfix]`.
+import { arg, body, cli, kind, run } from './lib.mjs';
+import { close } from './none.mjs';
+
+const usage = '<n> <comment file> [wontfix]';
+const n = arg(0, usage), file = arg(1, usage), wontfix = process.argv[4] === 'wontfix';
+const comment = body(file);
+if (kind() === 'none') close(n, comment, wontfix);
+else if (cli() === 'glab') {
+  run(['issue', 'note', n, '-m', comment]);
+  run(['issue', 'close', n]);
+  if (wontfix) run(['issue', 'update', n, '--label', 'wontfix']);
+} else {
+  run(['issue', 'comment', n, '--body-file', file]);
+  run(['issue', 'close', n]);
+  if (wontfix) run(['issue', 'edit', n, '--add-label', 'wontfix']);
+}
+console.log(`closed #${n}${wontfix ? ', wontfix' : ''}`);

package/scripts/tracker/create.mjs

@@ -0,0 +1,47 @@
+// `codelife issue create [--once] <bug|feature|lot|-> <severity|-> <origin|-> <file>` (review-mr
+// C-868): one new issue, the file's `# ` line its sentence and the rest its body; the title opens on the origin's
+// tag (`tagged` in lib.mjs), its labels are the nature and `severity-<s>` — an
+// umbrella's, `lot` alone after `[lot · <origin>]`; `-`, the roadmap's, none. Under
+// `tracker.kind: none`, a new `issues/NNN-<slug>.md`. Prints `created #<n> — <link or path>`; a
+// number that does not read back is a failure, never an empty one. With `--once`, an origin that
+// is an identifier — an audit's finding or lot — files nothing when an issue's tag already holds it,
+// open or closed, and prints `exists #<n> — <its line>`: what makes a cut filing run again.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { arg, cli, die, kind, run, tagged, text } from './lib.mjs';
+import { create } from './none.mjs';
+
+const once = process.argv[2] === '--once';
+if (once) process.argv.splice(2, 1);
+const usage = '[--once] <bug|feature|lot|-> <critical|high|mid|low|-> <origin|-> <file>';
+const nature = arg(0, usage), severity = arg(1, usage), origin = arg(2, usage), file = arg(3, usage);
+if (!['bug', 'feature', 'lot', '-'].includes(nature)) die(`usage: codelife issue create ${usage} — not '${nature}'`);
+if (!['critical', 'high', 'mid', 'low', '-'].includes(severity)) die(`usage: codelife issue create ${usage} — not '${severity}'`);
+const [, sentence = '', body = ''] = text(file).match(/^# (.+)\n+([\s\S]*)$/) ?? [];
+if (!sentence.trim() || !body.trim()) die(`${file}: a '# ' line, then the body`);
+const title = tagged(origin === '-' ? '' : origin, nature === 'lot', sentence.trim());
+if (once && origin !== '-') {
+  const key = join(mkdtempSync(join(tmpdir(), 'codelife-once-')), 'key');
+  writeFileSync(key, origin);
+  const r = spawnSync(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), 'search_id.mjs'), key, '--all'], { encoding: 'utf8' });
+  if (r.status !== 0) die((r.stderr || r.stdout).trim());
+  const hit = r.stdout.split('\n').find((l) => /^#\d+/.test(l));
+  if (hit) {
+    console.log(`exists ${hit.match(/^#\d+/)[0]} — ${hit}`);
+    process.exit(0);
+  }
+}
+const labels = [...(nature !== '-' ? [nature] : []), ...(severity !== '-' ? [`severity-${severity}`] : [])];
+if (kind() === 'none') {
+  const path = create(title, body, nature !== '-' ? nature : '', severity !== '-' ? severity : '');
+  console.log(`created #${Number(path.match(/issues\/(\d+)/)[1])} — ${path}`);
+} else {
+  const out = cli() === 'glab'
+    ? run(['issue', 'create', '-t', title, '-d', body, ...(labels.length ? ['-l', labels.join(',')] : []), '-y', '--no-editor'])
+    : run(['issue', 'create', '--title', title, '--body-file', '-', ...labels.flatMap((l) => ['--label', l])], body);
+  const url = out.trim().split('\n').at(-1).trim(), n = url.match(/\/(\d+)$/)?.[1];
+  console.log(n ? `created #${n} — ${url}` : die(`the issue was sent and its number does not read back: ${out.trim()}`));
+}

package/scripts/tracker/issue.section.mjs

@@ -0,0 +1,25 @@
+// `codelife issue section <n> <heading>`: one section of an issue —
+// the description from its `## <heading>` line, matched case-blind on the heading's opening words, to
+// the next `## `; `plan` prints instead the latest comment opening on `codelife: plan — `. Exit 1 when
+// the issue has no such section.
+import { arg, die } from './lib.mjs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const n = arg(0, '<n> <heading>'), heading = process.argv.slice(3).join(' ') || die('usage: codelife issue section <n> <heading>');
+const r = spawnSync(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), 'view.mjs'), n], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+if (r.status !== 0) die(r.stderr.trim());
+const issue = JSON.parse(r.stdout);
+let out;
+if (heading.toLowerCase() === 'plan') out = issue.comments.filter((c) => c.body.startsWith('codelife: plan — ')).at(-1)?.body;
+else {
+  const lines = issue.body.split('\n'), want = heading.toLowerCase();
+  const at = lines.findIndex((l) => l.startsWith('## ') && l.slice(3).toLowerCase().startsWith(want));
+  if (at >= 0) {
+    const end = lines.findIndex((l, i) => i > at && l.startsWith('## '));
+    out = lines.slice(at, end < 0 ? undefined : end).join('\n').trim();
+  }
+}
+if (!out) die(`#${n} has no ${heading.toLowerCase() === 'plan' ? '`codelife: plan` comment' : `section '## ${heading}'`}`);
+console.log(out);

package/scripts/tracker/issue.update.mjs

@@ -0,0 +1,13 @@
+// tracker.issue.update(n, body, title?): the body read from its file — `-` leaves it — and the title
+// from its own, when given.
+// `node issue.update.mjs <n> <body file>|- [<title file>]`.
+import { arg, body, cli, kind, run, text } from './lib.mjs';
+import { retitle, update } from './none.mjs';
+
+const usage = '<n> <body file>|- [<title file>]';
+const n = arg(0, usage), file = arg(1, usage), titled = process.argv[4];
+const description = file !== '-' && body(file), title = titled && text(titled).trim();
+if (kind() === 'none') { if (description) update(n, description); if (title) retitle(n, title); }
+else if (cli() === 'glab') run(['issue', 'update', n, ...(description ? ['--description', description] : []), ...(title ? ['--title', title] : [])]);
+else run(['issue', 'edit', n, ...(description ? ['--body-file', file] : []), ...(title ? ['--title', title] : [])]);
+console.log(`updated #${n}`);

package/scripts/tracker/issue.view.mjs

@@ -0,0 +1,16 @@
+// `codelife issue view <n>` (#1050): the issue whole, as a person reads it — its title, state and
+// labels, its description, then every comment and every close or reopening, oldest first, each under
+// its date and author. What view.mjs reads, written for a reader rather than a script.
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { arg, die } from './lib.mjs';
+
+const n = arg(0, '<n>');
+const r = spawnSync(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), 'view.mjs'), n], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+if (r.status !== 0) die(r.stderr.trim());
+const i = JSON.parse(r.stdout);
+const said = [...i.comments.map((c) => ({ date: c.date, head: `${c.date || 'undated'} — ${c.author || 'unknown'}`, body: c.body.trim() })),
+  ...i.events.map((e) => ({ date: e.date, head: `${e.date} — ${e.state}` }))].sort((a, b) => (a.date || '').localeCompare(b.date || ''));
+console.log([`# #${n} ${i.title}`, '', `- state: ${i.state}`, `- labels: ${i.labels.join(', ') || 'none'}`, '', i.body.trim(),
+  ...said.flatMap((c) => ['', `## ${c.head}`, ...(c.body ? ['', c.body] : [])])].join('\n'));

package/scripts/tracker/lib.mjs

@@ -0,0 +1,130 @@
+// What the scripts under scripts/tracker/ share — each runs one operation on the tracker, named after
+// it, and is the one place its forge form is written. From the repository's root: the CLI the
+// contract's `tracker.kind` names, origin's host and project read at each call, the user's token
+// variables stripped.
+import '../node-floor.mjs';
+import { execFile, spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { contract, valid } from '../contract.mjs';
+
+// TOKENS, env — the user's token variables, and the environment every forge call runs in without
+// them: the CLI's own stored login is the connection, never a variable a shell profile set.
+export const TOKENS = ['GITLAB_TOKEN', 'GITLAB_HOST', 'GH_TOKEN', 'GITHUB_TOKEN', 'GH_ENTERPRISE_TOKEN', 'GH_HOST'];
+export const env = () => Object.fromEntries(Object.entries(process.env).filter(([k]) => !TOKENS.includes(k)));
+
+export const die = (why) => {
+  console.error(why);
+  process.exit(1);
+};
+
+// kind — the contract's `tracker.kind`; `none` when it names no forge.
+export const kind = () => { const v = valid(); return v.stop ? die(v.stop) : v.contract.data.tracker?.kind || 'none'; };
+
+// cli — `glab` or `gh`, from the contract; under `none` every operation scripted here but those that
+// read `issues/` (none.mjs) is refused.
+export const cli = () => {
+  const k = kind();
+  if (k !== 'glab' && k !== 'gh') die(`refused under tracker.kind ${k}: a merge request has no file-based equivalent`);
+  return k;
+};
+
+// call <args> [input] — the CLI's { status, stdout, stderr, error }; its stdin is `input`, empty when
+// none is given, so a CLI that would ask a question answers at once rather than waiting.
+export const call = (args, input = '') => spawnSync(cli(), args, { encoding: 'utf8', env: env(), input, maxBuffer: 256 * 1024 * 1024 });
+
+// run <args> [input] — the CLI's stdout; its failure is the operation's, quoted, the contract's
+// `## Tracker notes` under it: the forge's traps the team wrote, read where one is met.
+const failed = (args, said) => {
+  const notes = contract()?.sections.get('Tracker notes');
+  die(`${cli()} ${args.join(' ')}: ${said.trim()}${notes ? `\n\nThe contract's ## Tracker notes:\n${notes}` : ''}`);
+};
+export const run = (args, input) => {
+  const r = call(args, input);
+  if (r.status !== 0) failed(args, r.stderr || r.stdout || r.error?.message || '');
+  return r.stdout;
+};
+// runLater <args> — run's answer as a promise, for reads made side by side, stdin closed (#1098).
+export const runLater = (args) => new Promise((resolve) => execFile(cli(), args, { encoding: 'utf8', env: env(), maxBuffer: 256 * 1024 * 1024 },
+  (e, out, err) => (e ? failed(args, err || out || e.message) : resolve(out))).stdin.end());
+// pool <items> <n> <fn> — fn over the items, n at a time, the answers in the items' order.
+export const pool = async (items, n, fn) => {
+  const out = new Array(items.length);
+  let i = 0;
+  await Promise.all(Array.from({ length: Math.min(n, items.length) }, async () => { while (i < items.length) { const k = i++; out[k] = await fn(items[k]); } }));
+  return out;
+};
+export const ndjson = (text) => text.split('\n').filter(Boolean).map((l) => JSON.parse(l));
+// comments <n> — the forge call that reads issue <n>'s comments, every page; commentsOf <its stdout>
+// — them, oldest first, { author, date, body }. On glab the notes API, its system notes dropped —
+// never `issue view --comments`, one page of 20 notes, system ones counted; on gh `issue view --json
+// comments`, a shape view.mjs's own call also has.
+export const comments = (n) => (cli() === 'glab' ? ['api', `projects/:id/issues/${n}/notes?sort=asc&per_page=100`, '--paginate', '--output', 'ndjson']
+  : ['issue', 'view', String(n), '--json', 'comments']);
+export const commentsOf = (out) => (cli() === 'glab' ? ndjson(out).filter((c) => !c.system).map((c) => ({ author: c.author?.username, date: c.created_at, body: c.body }))
+  : JSON.parse(out).comments.map((c) => ({ author: c.author?.login, date: c.createdAt, body: c.body })));
+export const git = (...args) => {
+  const r = spawnSync('git', args, { encoding: 'utf8' });
+  if (r.status !== 0) die(`git ${args.join(' ')}: ${r.stderr.trim()}`);
+  return r.stdout;
+};
+
+// origin — { host, project } from `git remote get-url origin`, both forms of step 1.
+// parseOrigin <url> — the same, or null when the URL reads as neither: a path on this machine.
+export const parseOrigin = (url) => {
+  const m = url.match(/^[^@/]+@([^:/]+):(.+?)(?:\.git)?$/) || url.match(/^[a-z+]+:\/\/(?:[^@/]+@)?([^/:]+)(?::\d+)?\/(.+?)(?:\.git)?$/);
+  return m ? { host: m[1], project: m[2] } : null;
+};
+export const origin = () => {
+  const url = git('remote', 'get-url', 'origin').trim();
+  return parseOrigin(url) ?? die(`origin ${url} reads as neither form`);
+};
+
+// pages <glab issue list flags> — every row, where `glab issue list` prints one page: 30 rows by
+// default, 100 at most. A failure of the CLI is the operation's.
+export const pages = (flags) => {
+  const rows = [];
+  for (let p = 1; ; p++) {
+    const page = run(['issue', 'list', ...flags, '-P', '100', '-p', String(p)]).split('\n').filter((l) => l.startsWith('#'));
+    rows.push(...page);
+    if (page.length < 100) return rows;
+  }
+};
+
+// text <file or fd> — what `$(cat <file>)` gives: the file, its trailing newlines gone. Forge text
+// arrives this way, by file or on stdin (`text(0)`), and never as an argument.
+export const text = (src) => readFileSync(src, 'utf8').replace(/\n+$/, '');
+// body <file> — the text a write publishes: refused, nothing sent, when the file holds only blank
+// lines, since an empty description or comment replaces what was there with nothing (#1062).
+export const body = (file) => text(file).trim() ? text(file) : die(`${file} is empty; nothing sent`);
+
+// word <term> — a test of whether a text holds the term as a whole word, regardless of case and as a
+// fixed string: what `grep -iwF` matches, so `hang` is not found inside `change`.
+export const word = (term) => {
+  const re = new RegExp(`(?<![A-Za-z0-9_])${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![A-Za-z0-9_])`, 'i');
+  return (s) => re.test(s);
+};
+
+// matching <term> [all] — the open issues the forge's search finds for one term, one line each, every
+// page; with `all`, the closed ones too. The term goes to the CLI as one argument, never through a shell.
+export const matching = (term, all) => (cli() === 'glab'
+  ? pages([`--search=${term}`, '--in', 'title,description', ...(all ? ['--all'] : [])])
+  : run(['issue', 'list', `--search=${term}`, '--state', all ? 'all' : 'open', '--limit', '100000']).split('\n').filter(Boolean));
+
+// rank <lines> — each line once, after the number of searches it came back from and a tab, the most
+// first, a tie in the order the lines first came. A line is known by its first tab-separated field —
+// an issue's number, whose row ends on an age that moves between searches.
+export const rank = (lines) => {
+  const seen = new Map();
+  for (const line of lines.filter(Boolean)) {
+    const k = line.split('\t')[0];
+    seen.set(k, { line: seen.get(k)?.line ?? line, n: (seen.get(k)?.n ?? 0) + 1 });
+  }
+  return [...seen.values()].sort((a, b) => b.n - a.n).map(({ line, n }) => `${n}\t${line}`);
+};
+
+export const first = (body = '') => body.split('\n')[0];
+
+// tagged <origin> <umbrella> <sentence> — the title an issue is filed under: `[<origin>] `, an
+// umbrella's `[lot · <origin>] ` — `[lot] ` with none —, or the sentence alone (templates.md R-75).
+export const tagged = (origin, umbrella, sentence) => `${umbrella ? `[lot${origin ? ` · ${origin}` : ''}] ` : origin ? `[${origin}] ` : ''}${sentence}`;
+export const arg = (i, what) => process.argv[2 + i] || die(`usage: node ${process.argv[1].split('/').pop()} ${what}`);

package/scripts/tracker/list.mjs

@@ -0,0 +1,14 @@
+// tracker.list(flags…): the open issues, one `#<n>\t<title>\t(<labels>)\t<when>` line each, every
+// page, whatever the tracker — the flags the CLI's own. On glab through `pages` of lib.mjs, which
+// reads past the 30 rows `glab issue list` prints; on gh from its JSON, since a piped row carries a
+// state column a reader of glab's rows does not expect (#1095); under `none`, the files of issues/,
+// every one with `-A`, other flags ignored (#1066).
+import { cli, kind, pages, run } from './lib.mjs';
+import { lines } from './none.mjs';
+
+const flags = process.argv.slice(2);
+const rows = kind() === 'none' ? lines(flags.includes('-A'))
+  : cli() === 'glab' ? pages(flags)
+  : JSON.parse(run(['issue', 'list', '--limit', '100000', '--json', 'number,title,labels,updatedAt', ...flags]))
+    .map((i) => `#${i.number}\t${i.title}\t(${i.labels.map((l) => l.name).join(', ')})\t${i.updatedAt}`);
+process.stdout.write(rows.map((l) => `${l}\n`).join(''));

package/scripts/tracker/list.whole.mjs

@@ -0,0 +1,20 @@
+// The open issues as one JSON array, { n, title, body, labels, comments } each, for a reader of every
+// one (`codelife overview`): the fields from one paginated list call, the comments only of an issue
+// that has some, four reads at a time — not each issue through view.mjs, three forge calls apiece,
+// which gitlab.com answered in minutes once dozens ran side by side (#1150). No state events: a
+// reader that needs an issue's reads view.mjs. Under `none`, the files of issues/.
+import { cli, comments, commentsOf, kind, ndjson, origin, pool, run, runLater } from './lib.mjs';
+import { lines, view } from './none.mjs';
+import { lf } from '../text.mjs';
+
+let issues;
+if (kind() === 'none') issues = lines(false).map((l) => Number(l.slice(1, l.indexOf('\t')))).map((n) => { const { title, body, labels, comments: c } = view(n); return { n, title, body, labels, comments: c }; });
+else {
+  const listed = cli() === 'glab'
+    ? ndjson(run(['api', 'projects/:id/issues?state=opened&per_page=100', '--paginate', '--output', 'ndjson']))
+      .map((i) => ({ n: i.iid, title: i.title, body: i.description || '', labels: i.labels || [], some: i.user_notes_count > 0 }))
+    : JSON.parse(run(['api', `repos/${origin().project}/issues?state=open&per_page=100`, '--paginate', '--slurp'])).flat().filter((i) => !i.pull_request)
+      .map((i) => ({ n: i.number, title: i.title, body: i.body || '', labels: i.labels.map((l) => l.name), some: i.comments > 0 }));
+  issues = await pool(listed, 4, async ({ some, ...i }) => ({ ...i, comments: some ? commentsOf(await runLater(comments(i.n))) : [] }));
+}
+console.log(JSON.stringify(issues, (_, v) => (typeof v === 'string' ? lf(v) : v)));

package/scripts/tracker/lot.row.mjs

@@ -0,0 +1,42 @@
+// An umbrella's body once one row of its `## The order` task list is written — the body on stdin, the
+// body printed, `issue.update` writing what it printed; a write already made leaves the body as it was:
+//   node lot.row.mjs add <member> <sentence file> [<effort>]   append `- [ ] #<member> (<effort>) <sentence>`
+//   node lot.row.mjs leave <member> <date> <reason file>       remove the row, one `Left on …` line under the list
+//   node lot.row.mjs tick <member>                             `- [ ] #<member>` → `- [x] #<member>`, that row only
+//   node lot.row.mjs untick <member>                           `- [x] #<member>` → `- [ ] #<member>`, that row only
+import { arg, die, text } from './lib.mjs';
+
+const usage = 'add <member> <sentence file> [<effort>] | leave <member> <date> <reason file> | tick <member> | untick <member>';
+const [mode, member] = [arg(0, usage), arg(1, usage)];
+const lines = text(0).split('\n');
+const start = lines.indexOf('## The order');   // a tick on a body without it reads the whole body
+if (start < 0 && !/^(un)?tick$/.test(mode)) die('the body has no `## The order` section');
+// The section's end, and the indexes in it of the lines matching <re>: read afresh after each splice.
+const end = () => { const e = lines.findIndex((l, i) => i > start && l.startsWith('## ')); return e < 0 ? lines.length : e; };
+const find = (re) => lines.flatMap((l, i) => (i > start && i < end() && re.test(l) ? [i] : []));
+const ROW = /^- \[[ xX]\] #\d+\b/;
+
+const mine = find(new RegExp(`^- \\[[ xX]\\] #${member}\\b`))[0];
+if (mode === 'tick') {
+  if (mine !== undefined) lines[mine] = lines[mine].replace(/^- \[ \]/, '- [x]');
+} else if (mode === 'untick') {
+  if (mine !== undefined) lines[mine] = lines[mine].replace(/^- \[[xX]\]/, '- [ ]');
+} else if (mode === 'add') {
+  if (mine === undefined) {
+    const effort = process.argv[5] ? ` (${process.argv[5]})` : '';
+    const row = `- [ ] #${member}${effort} ${text(arg(2, usage))}`;
+    const [rows, left] = [find(ROW), find(/^Left on /)];
+    if (rows.length) lines.splice(rows.at(-1) + 1, 0, row);
+    else if (left.length) lines.splice(left[0], 0, row, '');
+    else lines.splice(find(/./).at(-1) + 1 || start + 1, 0, '', row);
+  }
+} else if (mode === 'leave') {
+  const note = `Left on ${arg(2, usage)}: #${member} — ${text(arg(3, usage))}`;
+  if (mine !== undefined) lines.splice(mine, lines[mine - 1] === '' && lines[mine + 1] === '' ? 2 : 1);
+  if (!lines.includes(note)) {
+    const under = find(/^(- \[[ xX]\] #\d+\b|Left on )/);
+    if (under.length) lines.splice(under.at(-1) + 1, 0, ...(ROW.test(lines[under.at(-1)]) ? ['', note] : [note]));
+    else lines.splice(find(/./).at(-1) + 1 || start + 1, 0, '', note);
+  }
+} else die(`unknown mode ${mode}: ${usage}`);
+console.log(lines.join('\n'));

package/scripts/tracker/mr.checkout_command.mjs

@@ -0,0 +1,5 @@
+// tracker.mr.checkout_command(n): the user's command to reach the head — returned, never run.
+import { arg, cli } from './lib.mjs';
+
+const n = arg(0, '<n>');
+console.log(cli() === 'glab' ? `glab mr checkout ${n}` : `gh pr checkout ${n}`);

package/scripts/tracker/mr.comments.mjs

@@ -0,0 +1,50 @@
+// `codelife mr comments <n>` (C-865, C-867): what a later review pass carries and what /work-feedback
+// answers — the latest review pass whole, /work-feedback's answers to it, the comments people wrote
+// after it, and the threads a person opened that are still open. A pass is a general comment whose
+// first line reads `codelife: review — pass <k> — <sha>`, an answer `codelife: answer — pass <k> —`,
+// or `codelife: answer — comments —` where no pass was posted;
+// a record of codelife's other than these is no one's comment. Prints one `### comments` summary line block, then each body under its own heading.
+// Each list is read once. A thread is open when its first note is resolvable and not resolved —
+// on GitLab a diff discussion or a general one a person started, GitLab's system notes counted in
+// none; on gh a review thread, a conversation comment being no thread.
+import { arg, cli, first, origin, run } from './lib.mjs';
+
+const n = arg(0, '<n>');
+const PASS = /^codelife: review — pass (\d+) — ([0-9a-f]{7,40})$/;
+let notes, threads;
+if (cli() === 'glab') {
+  const { host, project } = origin();
+  const url = (x) => `https://${host}/${project}/-/merge_requests/${n}#note_${x.id}`;
+  const read = (type) => JSON.parse(run(['mr', 'note', 'list', n, '-t', type, '-F', 'json']) || '[]')
+    .map((d) => d.notes.filter((x) => !x.system)).filter((said) => said.length).map((said) => ({ said, author: said[0].author?.username,
+      path: said[0].position?.new_path ?? said[0].position?.old_path, open: !!said[0].resolvable && !said[0].resolved,
+      first: first(said[0].body), last: said.length > 1 ? first(said.at(-1).body) : '', url: url(said[0]) }));
+  const general = read('general');
+  threads = [...read('diff'), ...general];
+  notes = general.flatMap((t) => t.said.map((x) => ({ author: x.author?.username, date: x.created_at || '', body: x.body, url: url(x), open: t.open })));
+} else {
+  notes = JSON.parse(run(['pr', 'view', n, '--json', 'comments'])).comments
+    .map((c) => ({ author: c.author?.login, date: c.createdAt || '', body: c.body, url: c.url }));
+  const [o, r] = origin().project.split('/');
+  const query = 'query($o:String!,$r:String!,$n:Int!,$endCursor:String){repository(owner:$o,name:$r){pullRequest(number:$n){reviewThreads(first:50,after:$endCursor){pageInfo{hasNextPage endCursor} nodes{isResolved path first:comments(first:1){nodes{body url author{login}}} last:comments(last:1){nodes{body}} comments{totalCount}}}}}}';
+  threads = JSON.parse(run(['api', 'graphql', '--paginate', '--slurp', '-F', `o=${o}`, '-F', `r=${r}`, '-F', `n=${n}`, '-f', `query=${query}`]))
+    .flatMap((p) => p.data.repository.pullRequest.reviewThreads.nodes).map((t) => ({ author: t.first.nodes[0]?.author?.login, path: t.path,
+      open: !t.isResolved, first: first(t.first.nodes[0]?.body), last: t.comments.totalCount > 1 ? first(t.last.nodes[0]?.body) : '', url: t.first.nodes[0]?.url }));
+}
+notes.sort((x, y) => x.date.localeCompare(y.date));
+const passes = notes.map((c, i) => ({ ...c, i, m: first(c.body).match(PASS) })).filter((c) => c.m);
+const last = passes.at(-1);
+const since = notes.slice(last ? last.i + 1 : 0);
+const answers = since.filter((c) => first(c.body).startsWith(last ? `codelife: answer — pass ${last.m[1]} — ` : 'codelife: answer — comments — '));
+const after = since.filter((c) => !c.open && !first(c.body).startsWith('codelife:'));
+const open = threads.filter((t) => t.open && !t.first.startsWith('codelife:'));
+
+const out = ['### comments',
+  `- latest pass: ${last ? `${last.m[1]} — ${last.m[2]} — by ${last.author} — ${last.url}` : 'none'}`,
+  `- passes: ${passes.length ? passes.map((p) => `${p.m[1]} ${p.url}`).join(', ') : 'none'}`,
+  `- after it: ${answers.length} answer${answers.length === 1 ? '' : 's'}, ${after.length} comment${after.length === 1 ? '' : 's'} by people, ${open.length} open thread${open.length === 1 ? '' : 's'} a person opened`];
+if (last) out.push('', `#### pass ${last.m[1]} — ${last.url}`, '', last.body.trim());
+for (const c of answers) out.push('', `#### answer to ${last ? `pass ${last.m[1]}` : 'the comments'} by ${c.author} — ${c.url}`, '', c.body.trim());
+for (const c of after) out.push('', `#### comment by ${c.author} — ${c.date} — ${c.url}`, '', c.body.trim());
+for (const t of open) out.push('', `#### open thread by ${t.author}${t.path ? ` on ${t.path}` : ''} — ${t.url}`, '', `${t.first}${t.last ? `\n\nlatest: ${t.last}` : ''}`);
+console.log(out.join('\n'));

package/scripts/tracker/mr.create.mjs

@@ -0,0 +1,12 @@
+// tracker.mr.create(b, target, title file, body file): the merge request of branch `b` into `target`,
+// its source branch removed at the merge (the plugin's decision, not the project's checkbox) — prints
+// its link. `node mr.create.mjs <branch> <target> <title file> <body file>`.
+import { arg, body, cli, run, text } from './lib.mjs';
+
+const [b, target] = [0, 1].map((i) => arg(i, '<branch> <target> <title file> <body file>'));
+const title = text(arg(2, '<branch> <target> <title file> <body file>')), file = arg(3, '<branch> <target> <title file> <body file>');
+const description = body(file);
+const out = cli() === 'glab'
+  ? run(['mr', 'create', '-s', b, '-b', target, '-t', title, '-d', description, '--remove-source-branch', '--yes', '--no-editor'])
+  : run(['pr', 'create', '--base', target, '--head', b, '--title', title, '--body-file', file]);
+console.log(out.match(/https?:\/\/\S+/g)?.at(-1) ?? out.trim());