@ok-ggwp/git-gloss 0.2.0 → 0.4.0

package/dist/ary/server.js

@@ -0,0 +1,101 @@
+import { readFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { GlossError, WIP_REF, gitTry, resolveCommits } from '../git.js';
+import { buildPageData } from '../html/data.js';
+import { escapeHtml, renderPage } from '../html/page.js';
+import { listLog, listRefs } from './browse.js';
+const asset = (name) => readFileSync(new URL(name, import.meta.url), 'utf8');
+// A range page loads and lays out every commit in it, so a huge one would hang
+// the browser. Narrowing it is a better answer than a spinner.
+export const MAX_RANGE_COMMITS = 200;
+// The shell page loads only its own script and style, and may frame only
+// /view pages. Those carry their own policy: an inline script with a nonce.
+const SHELL_CSP = "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; frame-src 'self'; base-uri 'none'; form-action 'none'";
+class BadRequest extends GlossError {
+}
+// A revision, branch or range typed by the user or taken from the sidebar. An
+// option-looking one is refused so it can never be read by git as a flag.
+function revParam(url, name, required = true) {
+    const v = url.searchParams.get(name);
+    if (!v) {
+        if (required)
+            throw new BadRequest(`missing ?${name}=`);
+        return null;
+    }
+    if (v.startsWith('-') || v.length > 500 || v.includes('\0'))
+        throw new BadRequest(`not a revision: ${v.slice(0, 80)}`);
+    return v;
+}
+const intParam = (url, name, fallback, min, max) => {
+    const n = Number(url.searchParams.get(name) ?? fallback);
+    return Number.isInteger(n) && n >= min ? Math.min(n, max) : fallback;
+};
+function send(res, status, type, body, headers = {}) {
+    res.writeHead(status, {
+        'content-type': `${type}; charset=utf-8`,
+        // Everything reflects the repo as it is now.
+        'cache-control': 'no-store',
+        'x-content-type-options': 'nosniff',
+        'referrer-policy': 'no-referrer',
+        ...headers,
+    });
+    res.end(body);
+}
+const sendJson = (res, data) => send(res, 200, 'application/json', JSON.stringify(data));
+function viewPage(url) {
+    const rev = revParam(url, 'rev');
+    // "wip" is the latest snapshot of uncommitted work. The server never takes
+    // one (that is `git gloss hunks wip`): browsing doesn't change anything.
+    const target = rev === 'wip' ? gitTry(['rev-parse', '--verify', '--quiet', WIP_REF])?.trim() : rev;
+    if (!target)
+        throw new GlossError('no snapshot of uncommitted work yet; run `git gloss hunks wip` first');
+    const { shas, merges, range } = resolveCommits(target);
+    if (shas.length > MAX_RANGE_COMMITS) {
+        throw new GlossError(`${rev} has ${shas.length} commits; a page shows at most ${MAX_RANGE_COMMITS}. Pick a narrower range.`);
+    }
+    return renderPage(buildPageData(shas, range, merges));
+}
+function route(req, res, url) {
+    const shell = (name, type) => send(res, 200, type, asset(name), type === 'text/html' ? { 'content-security-policy': SHELL_CSP } : {});
+    switch (url.pathname) {
+        case '/': return shell('./index.html', 'text/html');
+        case '/ary.js': return shell('./client.js', 'text/javascript');
+        case '/ary.css': return shell('./style.css', 'text/css');
+        case '/api/refs': return sendJson(res, listRefs());
+        case '/api/log':
+            return sendJson(res, listLog(revParam(url, 'head'), revParam(url, 'base', false), intParam(url, 'limit', 100, 1, 500), intParam(url, 'skip', 0, 0, 1e6), (url.searchParams.get('q') ?? '').slice(0, 200)));
+        case '/view':
+            // The page may only be framed by the shell, not by another site.
+            return send(res, 200, 'text/html', viewPage(url), { 'content-security-policy': "frame-ancestors 'self'" });
+        default: return send(res, 404, 'text/plain', 'not found');
+    }
+}
+export function createAry(port) {
+    return createServer((req, res) => {
+        // A web page on another site can make the browser send requests here, and
+        // with DNS rebinding even read the answers. Only our own origin's host
+        // names get through; the server is read-only besides.
+        const allowed = [`127.0.0.1:${port()}`, `localhost:${port()}`];
+        if (!allowed.includes((req.headers.host ?? '').toLowerCase()))
+            return send(res, 403, 'text/plain', `forbidden host: this server answers to ${allowed.join(' and ')} (it listens on this machine only; through an SSH tunnel, forward the same port number)`);
+        if (req.method !== 'GET' && req.method !== 'HEAD')
+            return send(res, 405, 'text/plain', 'read-only', { allow: 'GET, HEAD' });
+        const url = new URL(req.url ?? '/', 'http://localhost');
+        try {
+            route(req, res, url);
+        }
+        catch (err) {
+            if (!(err instanceof GlossError)) {
+                console.error(err);
+                return send(res, 500, 'text/plain', 'internal error');
+            }
+            const status = err instanceof BadRequest ? 400 : 422;
+            if (url.pathname === '/view') {
+                send(res, status, 'text/html', `<!doctype html><meta charset="utf-8"><meta name="color-scheme" content="light dark"><pre style="white-space:pre-wrap;font:14px/1.5 system-ui;padding:16px">${escapeHtml(err.message)}</pre>`, { 'content-security-policy': "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'self'" });
+            }
+            else {
+                send(res, status, 'application/json', JSON.stringify({ error: err.message }));
+            }
+        }
+    });
+}

package/dist/ary/style.css

@@ -0,0 +1,115 @@
+:root {
+  --bg: #f7f7f5;
+  --surface: #ffffff;
+  --surface-2: #f1f1ee;
+  --border: #e2e2dc;
+  --text: #1d1d1b;
+  --muted: #6b6b66;
+  --accent: #3b5bdb;
+  --ok: #1a7f37;
+  --warn-bg: #fff4e5;
+  --warn-border: #f0b35b;
+  --warn-text: #7a4300;
+  --mono: ui-monospace, SFMono-Regular, Menlo, Consolas, "Liberation Mono", monospace;
+  --sans: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  color-scheme: light;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #151514;
+    --surface: #1e1e1c;
+    --surface-2: #262624;
+    --border: #34342f;
+    --text: #e8e8e3;
+    --muted: #9a9a92;
+    --accent: #8ea2ff;
+    --ok: #57c47a;
+    --warn-bg: #33270f;
+    --warn-border: #a2701e;
+    --warn-text: #f3c77a;
+    color-scheme: dark;
+  }
+}
+
+* { box-sizing: border-box; }
+html, body, #app { height: 100%; }
+body { margin: 0; background: var(--bg); color: var(--text); font: 14px/1.45 var(--sans); }
+button, input, select { font: inherit; color: inherit; }
+
+.shell { display: grid; grid-template-columns: 340px minmax(0, 1fr); height: 100%; }
+@media (max-width: 800px) {
+  .shell { grid-template-columns: minmax(0, 1fr); grid-template-rows: minmax(0, 45%) minmax(0, 1fr); }
+}
+
+/* Sidebar */
+.side { display: flex; flex-direction: column; min-height: 0; border-right: 1px solid var(--border); background: var(--surface); }
+.side-top { padding: 12px; border-bottom: 1px solid var(--border); display: grid; gap: 10px; }
+.title { display: flex; align-items: baseline; justify-content: space-between; gap: 8px; }
+.title strong { font-size: 15px; }
+.title .repo { color: var(--muted); font-family: var(--mono); font-size: 12px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+label.field, div.field { display: grid; gap: 3px; color: var(--muted); font-size: 11.5px; text-transform: uppercase; letter-spacing: 0.05em; }
+label.field > input, .rev-row input, .combo-btn, .combo-panel input {
+  width: 100%; padding: 5px 8px; border: 1px solid var(--border); border-radius: 6px;
+  background: var(--bg); text-transform: none; letter-spacing: 0; font-size: 13px;
+}
+.combo { position: relative; }
+.combo-btn { text-align: left; cursor: pointer; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; padding-right: 24px; position: relative; }
+.combo-btn::after { content: "▾"; position: absolute; right: 8px; color: var(--muted); }
+.combo-panel {
+  position: absolute; z-index: 10; left: 0; right: 0; top: calc(100% + 4px);
+  display: grid; gap: 6px; padding: 6px; border: 1px solid var(--border); border-radius: 8px;
+  background: var(--surface); box-shadow: 0 8px 24px rgb(0 0 0 / 0.25);
+}
+.combo-panel[hidden] { display: none; }
+.combo-list { max-height: min(50vh, 320px); overflow: auto; }
+.combo-group {
+  margin-top: 8px; padding: 10px 8px 4px; border-top: 1px solid var(--border);
+  font-size: 11px; font-weight: 700; text-transform: uppercase; letter-spacing: 0.06em; color: var(--text);
+}
+.combo-group:first-child { margin-top: 0; padding-top: 4px; border-top: 0; }
+.combo-group .count { margin-left: 6px; color: var(--muted); font-weight: 400; }
+.combo-item { display: block; width: 100%; text-align: left; border: 0; background: none; border-radius: 5px; padding: 4px 8px 4px 20px; cursor: pointer; font-family: var(--mono); font-size: 12.5px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.combo-item:hover, .combo-item.active { background: var(--surface-2); }
+.combo-item[aria-selected="true"] { color: var(--accent); font-weight: 600; }
+.combo-more { padding: 6px 8px; color: var(--muted); font-size: 12.5px; }
+.rev-row { display: flex; gap: 6px; }
+.rev-row input { font-family: var(--mono); font-size: 12.5px; }
+.btn {
+  border: 1px solid var(--border); background: var(--surface); border-radius: 6px;
+  padding: 4px 10px; cursor: pointer; white-space: nowrap;
+}
+.btn:hover { background: var(--surface-2); }
+.error { margin: 0; padding: 8px 10px; border-radius: 6px; background: var(--warn-bg); border: 1px solid var(--warn-border); color: var(--warn-text); font-size: 12.5px; }
+
+.list { flex: 1; min-height: 0; overflow: auto; padding: 6px; }
+.list h2 { margin: 10px 8px 4px; font-size: 11.5px; text-transform: uppercase; letter-spacing: 0.05em; color: var(--muted); font-weight: 600; }
+.row {
+  display: block; width: 100%; text-align: left; cursor: pointer;
+  border: 1px solid transparent; background: none; border-radius: 6px; padding: 6px 8px;
+}
+.row:hover { background: var(--surface-2); }
+.row[aria-current="true"] { background: var(--surface-2); border-color: var(--accent); }
+.row .subject {
+  /* the whole point of the list: enough of the subject to tell commits apart */
+  display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 2; line-clamp: 2;
+  overflow: hidden; overflow-wrap: anywhere;
+}
+.row .meta { display: flex; flex-wrap: wrap; align-items: baseline; margin-top: 2px; color: var(--muted); font-size: 12px; }
+.row .marks { margin-left: auto; padding-left: 10px; display: inline-flex; gap: 10px; white-space: nowrap; }
+.sha { font-family: var(--mono); font-size: 12px; }
+.mark.glossed { color: var(--ok); }
+.mark.reviewed { color: var(--accent); }
+.mark.warn { color: var(--warn-text); background: var(--warn-bg); border-radius: 4px; padding: 0 5px; }
+.search-bar { padding: 8px 12px; border-bottom: 1px solid var(--border); }
+.search-bar input { width: 100%; padding: 5px 8px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); font-size: 13px; }
+.empty { color: var(--muted); padding: 8px; }
+.more { margin: 6px 8px; }
+
+/* Viewer */
+.viewer { display: flex; flex-direction: column; min-width: 0; min-height: 0; }
+.viewer-bar { display: flex; align-items: center; gap: 10px; padding: 8px 12px; border-bottom: 1px solid var(--border); background: var(--surface); }
+.viewer-bar .what { flex: 1; min-width: 0; font-family: var(--mono); font-size: 12.5px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.viewer-bar a { color: var(--accent); text-decoration: none; }
+.viewer-bar a:hover { text-decoration: underline; }
+iframe { flex: 1; width: 100%; min-height: 0; border: 0; background: var(--bg); }
+.placeholder { flex: 1; display: grid; place-items: center; color: var(--muted); padding: 24px; text-align: center; }

package/dist/attention.js

@@ -0,0 +1,34 @@
+import { ATTENTION, IMPACT } from './schema.js';
+// Rank of a group's impact; a group with none is below every level.
+export const impactRank = (i) => (i ? IMPACT.indexOf(i) : -1);
+export const maxImpact = (a, b) => (impactRank(b) > impactRank(a) ? b : a);
+export const attentionRank = (a) => (a ? ATTENTION.indexOf(a) : -1);
+export const maxAttention = (a, b) => (attentionRank(b) > attentionRank(a) ? b : a);
+// One step up, capped at must-read.
+export const raise = (a) => ATTENTION[Math.min(ATTENTION.length - 1, ATTENTION.indexOf(a) + 1)];
+// The attention a given impact calls for, before any raising.
+const ATTENTION_FOR_IMPACT = {
+    local: 'skim', module: 'look', shared: 'careful', contract: 'careful', sensitive: 'must-read',
+};
+export const attentionForImpact = (i) => ATTENTION_FOR_IMPACT[i];
+// What the reviewer should do when glosses are combined (a squash, a rebase):
+// the highest level of any of them. Focus groups of all of them, renamed to
+// their new ids (`rename` returns undefined for a group that is gone), most
+// impactful first, without repeats, at most three. Reasons are unioned.
+export function combineAttention(parts, rename, groups) {
+    if (!parts.length)
+        return undefined;
+    const level = parts.map((p) => p.level).reduce((a, b) => (ATTENTION.indexOf(b) > ATTENTION.indexOf(a) ? b : a));
+    const impactOf = new Map(groups.map((g) => [g.id, g.impact]));
+    const focus = [...new Set(parts.flatMap((p, i) => (p.focus ?? []).flatMap((id) => rename(i, id) ?? [])))]
+        .sort((a, b) => impactRank(impactOf.get(b)) - impactRank(impactOf.get(a)))
+        .slice(0, 3);
+    const reasons = [...new Set(parts.flatMap((p) => p.reasons ?? []))];
+    const overrides = [...new Set(parts.flatMap((p) => (p.override_reason && p.level === level ? [p.override_reason] : [])))];
+    return {
+        level,
+        ...(focus.length ? { focus } : {}),
+        ...(reasons.length ? { reasons } : {}),
+        ...(overrides.length ? { override_reason: overrides.join('; ') } : {}),
+    };
+}

package/dist/carry.js

@@ -52,5 +52,8 @@ export function carryGloss(note, current, previous = []) {
     const byId = new Map(current.map((h) => [h.id, h]));
     const claims = groups.flatMap((g) => [...selections(g.hunks, (id) => { const h = byId.get(id); return h && changedCount(h); })]
         .flatMap(([id, lines]) => { const h = byId.get(id); return h ? [{ hunk: h, lines }] : []; }));
-    return { annotation: { ...a, groups }, kept: groups.length, total: a.groups.length, dropped, gaps: uncovered(current, claims), partialMatch };
+    // Focus groups that were left behind can't be pointed at.
+    const focus = a.attention?.focus?.filter((id) => keptIds.has(id));
+    const attention = a.attention && { ...a.attention, focus: focus?.length ? focus : undefined };
+    return { annotation: { ...a, groups, ...(attention ? { attention } : {}) }, kept: groups.length, total: a.groups.length, dropped, gaps: uncovered(current, claims), partialMatch };
 }

package/dist/cli.js

@@ -1,6 +1,7 @@
 import { GlossError } from './git.js';
 import * as add from './commands/add.js';
 import * as adopt from './commands/adopt.js';
+import * as ary from './commands/ary.js';
 import * as carry from './commands/carry.js';
 import * as html from './commands/html.js';
 import * as hunks from './commands/hunks.js';
@@ -9,11 +10,12 @@ import * as review from './commands/review.js';
 import * as reviews from './commands/reviews.js';
 import * as schema from './commands/schema.js';
 import * as show from './commands/show.js';
+import * as signals from './commands/signals.js';
 import * as sync from './commands/sync.js';
 import * as versions from './commands/versions.js';
 import * as why from './commands/why.js';
 const COMMANDS = {
-    init, hunks, add, adopt, carry, show, html, why, review, reviews, sync, versions, schema,
+    init, hunks, signals, add, adopt, carry, show, html, ary, why, review, reviews, sync, versions, schema,
 };
 function help() {
     return 'usage: git gloss <command> [options]\n\n' +

package/dist/commands/add.js

@@ -5,7 +5,9 @@ import { commitDiff, isWipSnapshot, NOTES_REF, readNote, resolveCommit, WIP_NOTE
 import { location, parseDiff } from '../diff.js';
 import { Annotation, noteFormat } from '../schema.js';
 import { validate } from '../validate.js';
-export const usage = 'add [<commit>] [-f <file>] [--force] [--partial] [--dry-run]   attach an annotation (JSON from file or stdin)';
+import { loadConfig } from '../config.js';
+import { analyzeGroups, groupInputsFor, ratingProblems } from '../floor.js';
+export const usage = 'add [<commit>] [-f <file>] [--force] [--partial] [--allow-underrate] [--dry-run]   attach an annotation (JSON from file or stdin)';
 export function run(argv) {
     const { values, positionals } = parseArgs({
         args: argv,
@@ -14,6 +16,7 @@ export function run(argv) {
             file: { type: 'string', short: 'f' },
             force: { type: 'boolean' },
             partial: { type: 'boolean' },
+            'allow-underrate': { type: 'boolean' },
             'dry-run': { type: 'boolean' },
         },
     });
@@ -41,10 +44,23 @@ export function run(argv) {
     if (uncovered.length && !values.partial) {
         errors.push(`hunks not assigned to any group: ${uncovered.join(', ')} (every hunk needs a group, or pass --partial)`);
     }
+    // Computed signals: group impact below its floor is a warning; attention
+    // below the floor is an error unless explained (override_reason) or allowed.
+    // A malformed config stops here with its own message.
+    const warnings = [];
+    if (!errors.length) {
+        const analysis = analyzeGroups(hunks, groupInputsFor(parsed.data, hunks), loadConfig());
+        const problems = ratingProblems(parsed.data, analysis);
+        warnings.push(...problems.warnings);
+        if (problems.underrated)
+            (values['allow-underrate'] ? warnings : errors).push(problems.underrated);
+    }
     if (errors.length) {
         console.error('error: annotation is inconsistent with the commit:\n' + errors.map((e) => `  ✖ ${e}`).join('\n'));
         return 1;
     }
+    for (const w of warnings)
+        console.error(`warning: ${w}`);
     // Not an error: long intents still work, but they make the summary rows tall.
     for (const g of parsed.data.groups.filter((g) => g.intent.length > 100)) {
         console.error(`note: group "${g.id}" has a ${g.intent.length}-character intent; keep it under ~80 and move detail to "notes"`);

package/dist/commands/ary.js

@@ -0,0 +1,35 @@
+import { parseArgs } from 'node:util';
+import { createAry } from '../ary/server.js';
+import { GlossError, git } from '../git.js';
+import { openInBrowser } from './html.js';
+export const usage = 'ary [--port <n>] [--no-open]   browse glosses of branches, commits and uncommitted work in a local web page';
+// Starts a read-only server on this machine and keeps running until stopped.
+// The browser page lists branches and commits and shows each selection with
+// the same view as `git gloss html`.
+export function run(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: { port: { type: 'string' }, 'no-open': { type: 'boolean' } },
+    });
+    // Number('') and Number(' ') are 0, which would quietly mean "any port".
+    const port = values.port === undefined ? 0 : /^\d+$/.test(values.port) ? Number(values.port) : NaN;
+    if (!Number.isInteger(port) || port > 65535)
+        throw new GlossError(`not a port: ${values.port}`);
+    git(['rev-parse', '--git-dir']); // fail early outside a repository
+    let boundPort = port;
+    const server = createAry(() => boundPort);
+    server.on('error', (err) => {
+        console.error(`error: ${err.code === 'EADDRINUSE' ? `port ${port} is in use` : err.message}`);
+        process.exitCode = 1;
+    });
+    // Loopback only: the view includes the code of your commits.
+    server.listen(port, '127.0.0.1', () => {
+        boundPort = server.address().port;
+        const url = `http://127.0.0.1:${boundPort}/`;
+        console.log(url);
+        console.error('serving glosses read-only; press Ctrl-C to stop');
+        if (!values['no-open'])
+            openInBrowser(url);
+    });
+    return 0;
+}

package/dist/commands/html.js

@@ -7,7 +7,7 @@ import { resolveCommits } from '../git.js';
 import { buildPageData } from '../html/data.js';
 import { renderPage } from '../html/page.js';
 export const usage = 'html [<commit> | <range>] [-o <file>] [--open]   write a self-contained HTML view of a gloss, or of every commit in a range';
-function openInBrowser(file) {
+export function openInBrowser(file) {
     const [cmd, args] = process.platform === 'darwin' ? ['open', [file]]
         : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', file]]
             : ['xdg-open', [file]];

package/dist/commands/hunks.js

@@ -6,6 +6,10 @@ import { location, parseDiff } from '../diff.js';
 import { noteFormat } from '../schema.js';
 import { colorDiff, hunkLabel, page, style } from '../render.js';
 import { bodyLines, changedCount } from '../selection.js';
+import { loadConfig } from '../config.js';
+import { withSignals } from '../floor.js';
+import { analyze } from '../signals.js';
+import { summaryLines } from './signals.js';
 export const usage = 'hunks [<commit> | wip] [--stat] [--json]   list a commit\'s hunks (or snapshot uncommitted work with wip), numbering changed lines';
 export function run(argv) {
     const { values, positionals } = parseArgs({
@@ -59,6 +63,9 @@ export function run(argv) {
             return colorDiff(h.text, '       ');
         return [colorDiff(header, '       '), ...body.map((l) => style('dim', (l.idx === null ? '' : String(l.idx)).padStart(5)) + '  ' + colorDiff(l.raw))].join('\n');
     };
-    page(hunks.map((h) => hunkLabel(h) + style('dim', `  (${changedCount(h)} changed)`) + (values.stat ? '' : '\n' + numbered(h) + '\n')).join('\n'));
+    // What the diff itself says about attention, for the author to read before glossing.
+    const summary = withSignals(() => summaryLines(analyze(hunks, loadConfig())));
+    const signals = summary ? ['', ...summary] : [];
+    page([hunks.map((h) => hunkLabel(h) + style('dim', `  (${changedCount(h)} changed)`) + (values.stat ? '' : '\n' + numbered(h) + '\n')).join('\n'), ...signals].join('\n'));
     return 0;
 }

package/dist/commands/init.js

@@ -122,7 +122,12 @@ export function run(argv = []) {
         // The hooks run `git gloss`; a git without it on PATH (a GUI client, a
         // different shell) would print an error after every commit and push.
         if (spawnSync('sh', ['-c', 'command -v git-gloss'], { stdio: 'ignore' }).status !== 0) {
-            console.log('! git-gloss is not on PATH here; the hooks need it wherever git runs (see README: npm link)');
+            // Without it, every commit and push prints an error and the gloss isn't
+            // moved, synced or carried, so say that plainly.
+            console.log('! git-gloss is not on PATH in this shell, so the hooks will fail on every commit and push.');
+            console.log('  Their errors are only warnings, and glosses are not adopted, carried or synced until it is fixed.');
+            console.log('  Either install it globally (npm install -g @ok-ggwp/git-gloss), or, for a project install,');
+            console.log('  put its node_modules/.bin first on PATH in each hook (see README: "Project installs").');
         }
         installHook('pre-push', HOOK, '`git push` now syncs glosses with the remote it pushes to', [
             'git remote | grep -qxF -- "$1" && { GIT_TERMINAL_PROMPT=0 git gloss sync "$1" --pushing >&2 ||',

package/dist/commands/show.js

@@ -2,10 +2,12 @@ import { parseArgs } from 'node:util';
 import { commitSubject, gitTry, readNote, resolveCommits } from '../git.js';
 import { refLabel, sliceStats, sliceText } from '../selection.js';
 import { loadGloss } from '../loader.js';
-import { NECESSITY } from '../schema.js';
+import { impactRank } from '../attention.js';
+import { showsImpact, tryAnalyze } from '../floor.js';
+import { IMPACT, NECESSITY, isImpact, isNecessity } from '../schema.js';
 import { current, reviewStatus, statusPhrase, verdict } from '../reviews.js';
-import { colorDiff, field, groupHeader, hunkLabel, necessityWord, noteFooter, page, style, termWidth, wrap, } from '../render.js';
-export const usage = 'show [<commit> | <range>] [-g <group>]... [--full] [--diff] [--only <necessity,...>]   summarise a gloss, or each commit in a range';
+import { attentionBlock, colorDiff, derivedImpactTag, field, groupHeader, hunkLabel, IMPACT_W, impactTag, necessityWord, noteFooter, page, style, termWidth, wrap, } from '../render.js';
+export const usage = 'show [<commit> | <range>] [-g <group>]... [--full] [--diff] [--only <necessity|impact,...> (a group must match each kind named)] [--sort impact]   summarise a gloss, or each commit in a range';
 // Counts over the lines each part selects, not whole hunks, so groups that
 // split a hunk don't both count all of it.
 function stats(parts) {
@@ -26,12 +28,18 @@ export function run(argv) {
             full: { type: 'boolean' },
             diff: { type: 'boolean' },
             only: { type: 'string' },
+            sort: { type: 'string' },
         },
     });
-    const only = values.only?.split(',').map((s) => s.trim());
-    const unknown = only?.filter((n) => !NECESSITY.includes(n));
+    const names = values.only?.split(',').map((s) => s.trim());
+    const unknown = names?.filter((n) => !isNecessity(n) && !isImpact(n));
     if (unknown?.length) {
-        console.error(`error: unknown necessity ${unknown.join(', ')}; expected ${NECESSITY.join(', ')}`);
+        console.error(`error: unknown necessity or impact ${unknown.join(', ')}; expected ${NECESSITY.join(', ')} or ${IMPACT.join(', ')}`);
+        return 2;
+    }
+    const only = names && { names, necessities: names.filter(isNecessity), impacts: names.filter(isImpact) };
+    if (values.sort !== undefined && values.sort !== 'impact') {
+        console.error(`error: unknown sort ${values.sort}; expected impact`);
         return 2;
     }
     const { shas, merges, range } = resolveCommits(positionals[0] ?? 'HEAD');
@@ -63,7 +71,7 @@ export function run(argv) {
         }
         const out = renderCommit(sha, gloss, values, only, true);
         if (!out) {
-            console.error(`no groups match ${[values.group && `-g ${values.group.join(',')}`, only && `--only ${only.join(',')}`].filter(Boolean).join(' and ')}`);
+            console.error(`no groups match ${[values.group && `-g ${values.group.join(',')}`, only && `--only ${only.names.join(',')}`].filter(Boolean).join(' and ')}`);
             return 1;
         }
         page(out.join('\n'));
@@ -99,13 +107,15 @@ export function run(argv) {
         }
         // An --only filter can leave a commit with nothing to show; say so and move on.
         out.push(...(renderCommit(sha, gloss, values, only, false) ??
-            [`${style('yellow', sha.slice(0, 10))} ${style('bold', gloss.subject)}`, style('dim', `no ${only?.join('/')} groups`)]));
+            [`${style('yellow', sha.slice(0, 10))} ${style('bold', gloss.subject)}`, style('dim', `no ${only?.names.join('/')} groups`)]));
     });
     if (glossed)
         out.push('', style('dim', 'One commit in detail: git gloss show <commit> --full   (or -g <group> for its code)'));
     page(out.join('\n'));
     return 0;
 }
+const matchesOnly = (g, only) => !only ||
+    ((!only.necessities.length || only.necessities.includes(g.necessity)) && (!only.impacts.length || (!!g.impact && only.impacts.includes(g.impact))));
 // One line on whether the commit as it is now was reviewed, per stage.
 function reviewsLine(sha) {
     const statuses = reviewStatus(sha);
@@ -126,15 +136,25 @@ function renderCommit(sha, gloss, values, only, hints) {
         out.push(...field('summary:', a.summary, 0));
     for (const w of gloss.warnings)
         out.push(...field('⚠', w, 0).map((l) => style('red', l)));
-    out.push(reviewsLine(sha));
+    const an = tryAnalyze(gloss);
+    out.push(...attentionBlock(a.attention, an ? { floor: an.floor, derived: an.derived } : undefined), reviewsLine(sha));
     const groups = gloss.groups
-        .filter((g) => !only || only.includes(g.group.necessity))
+        .filter((g) => matchesOnly(g.group, only))
         .filter((g) => !values.group || values.group.includes(g.group.id));
     if (!groups.length)
         return null;
+    // --sort impact: the most consequential first, then by necessity as usual.
+    const byNecessity = (x, y) => NECESSITY.indexOf(x.group.necessity) - NECESSITY.indexOf(y.group.necessity);
+    const byImpact = (x, y) => impactRank(y.group.impact) - impactRank(x.group.impact) || byNecessity(x, y);
+    const detail = values.group || values.full || values.diff;
+    // The summary lists required first; detail views keep the gloss's order unless asked.
+    if (values.sort === 'impact')
+        groups.sort(byImpact);
+    else if (!detail)
+        groups.sort(byNecessity);
     // -g: chosen groups with their code. --full: every group's details, plus
     // alternatives and risks. --diff: --full plus code.
-    if (values.group || values.full || values.diff) {
+    if (detail) {
         const withCode = values.diff || !!values.group;
         for (const g of groups) {
             out.push('', ...groupHeader(g.group));
@@ -163,13 +183,12 @@ function renderCommit(sha, gloss, values, only, hints) {
         return out;
     }
     // Summary: one line per group.
-    const sorted = [...groups].sort((x, y) => NECESSITY.indexOf(x.group.necessity) - NECESSITY.indexOf(y.group.necessity));
     const tally = NECESSITY.map((n) => [n, gloss.groups.filter((g) => g.group.necessity === n).length])
         .filter(([, c]) => c > 0)
         .map(([n, c]) => `${c} ${necessityWord(n)}`);
-    const showing = groups.length < gloss.groups.length ? style('dim', `  (showing ${groups.length}: --only ${only?.join(',')})`) : '';
+    const showing = groups.length < gloss.groups.length ? style('dim', `  (showing ${groups.length}: --only ${only?.names.join(',')})`) : '';
     out.push('', `${style('bold', `${gloss.groups.length} groups:`)} ${tally.join(style('dim', ' · '))}${showing}`, '');
-    const rows = sorted.map((g) => {
+    const rows = groups.map((g) => {
         const s = stats(currentParts(g));
         const stale = g.hunks.filter((h) => h.status !== 'ok').length;
         return {
@@ -182,14 +201,21 @@ function renderCommit(sha, gloss, values, only, hints) {
     const statW = Math.max(...rows.map((r) => r.stat.length), un.count ? 8 : 0);
     const addW = Math.max(...rows.map((r) => r.added.length));
     const remW = Math.max(...rows.map((r) => r.removed.length));
-    const intentCol = 2 + 11 + 2 + idW + 2;
+    // An impact column only when some group declares one or the diff puts one
+    // above the baseline (module), so plain glosses look as before. Undeclared
+    // ones show the group's floor in parentheses.
+    const floorOf = (g) => an?.groups.get(g.group.id)?.floor;
+    const showImpact = showsImpact(gloss.groups.map((g) => g.group), an);
+    const impactW = showImpact ? IMPACT_W + 2 : 0;
+    const anyDerived = showImpact && gloss.groups.some((g) => !g.group.impact && floorOf(g));
+    const intentCol = 2 + 11 + 2 + impactW + idW + 2;
     const statsW = 2 + statW + 1 + addW + 1 + remW;
     const intentW = Math.max(20, termWidth() - intentCol - statsW);
     for (const r of rows) {
         // Intents wrap within their column rather than being cut off; the stats
         // stay on the first line so the numbers still line up.
         const [first, ...rest] = wrap(r.g.group.intent, intentW);
-        out.push(`  ${necessityWord(r.g.group.necessity, 11)}  ${style('bold', r.g.group.id.padEnd(idW))}  ` +
+        out.push(`  ${necessityWord(r.g.group.necessity, 11)}  ${impactW ? (r.g.group.impact ? impactTag(r.g.group.impact, IMPACT_W) : floorOf(r.g) ? derivedImpactTag(floorOf(r.g), IMPACT_W) : ' '.repeat(IMPACT_W)) + '  ' : ''}${style('bold', r.g.group.id.padEnd(idW))}  ` +
             `${first.padEnd(intentW)}  ` +
             style('dim', r.stat.padStart(statW)) + ' ' + style('green', r.added.padStart(addW)) + ' ' + style('red', r.removed.padStart(remW)), ...rest.map((l) => ' '.repeat(intentCol) + l));
         if (r.stale) {
@@ -200,6 +226,8 @@ function renderCommit(sha, gloss, values, only, hints) {
         const where = gloss.unannotated.map((u) => refLabel(u.hunk.id, u.lines)).join(', ');
         out.push(`  ${style(['bold', 'red'], 'unannotated'.padEnd(11))}  ${style('red', `+${un.added} -${un.removed} not in any group: ${where}`)}`);
     }
+    if (anyDerived)
+        out.push('', style('dim', '(impact in parentheses is derived from the diff, not declared)'));
     // Rejected alternatives and risks: short, and often what a reader most
     // lacks, so they're in the summary rather than only behind --full.
     out.push(...noteFooter(gloss.note));