@north-light/crouter 0.3.182 → 0.3.183

package/dist/clients/attach/render/{markdown-headings.d.ts → markdown-source.d.ts}

@@ -1,7 +1,7 @@
-/** Style ATX headings with a scan-friendly terminal hierarchy. The Markdown
- * markers are syntax, not content, so omit them from the rendered line.
- * Fenced examples remain literal Markdown, never decorated terminal output. */
-export declare function styleAttachMarkdownHeadings(markdown: string): string;
+/** Decorate a Markdown block for terminal rendering: heading hierarchy and XML
+ *  tag lines. Fenced examples remain literal Markdown, never decorated
+ *  terminal output. */
+export declare function styleAttachMarkdownSource(markdown: string): string;
 /** Copy a pi message for terminal rendering and decorate only Markdown-bearing
  * text/thinking blocks. The broker's source event is never mutated. */
 export declare function styleAttachMessageMarkdown<T>(message: T): T;

package/dist/clients/attach/render/markdown-source.js

@@ -0,0 +1,165 @@
+// Source-text transforms the attach viewer applies before pi-tui parses a
+// Markdown block. Every transform here rewrites the DISPLAY copy only —
+// persisted messages and copied text stay ordinary Markdown without terminal
+// escape sequences.
+//
+// HEADINGS. pi-tui's MarkdownTheme exposes one `heading(text)` callback without
+// the heading depth. Its renderer does know the depth, but does not pass it to
+// the theme, so every heading otherwise receives the same yellow mdHeading
+// paint. Decorate only the source text of H3–H6: pi still owns parsing,
+// wrapping, inline formatting, and H1/H2's established styling.
+//
+// XML TAG LINES. crouter's own context is XML-framed (`<crtr-bearings>`,
+// `<memory …>`, `<environment …>`), and agents quote XML in replies. A line
+// that is nothing but a tag opens a CommonMark HTML block, which runs to the
+// next blank line and renders as undecorated raw text — so `# Heading` on the
+// line after `<memory …>` came out as literal text with its `#`, and a closing
+// tag hanging off a list got absorbed into the last list item. Painting the tag
+// line means it no longer starts with `<`, so no HTML block opens and the
+// Markdown inside the envelope parses normally; a blank line on each side keeps
+// the tag from joining the paragraph or list beside it.
+//
+// GLYPHS. Private-use `U+XXXX` references become their glyphs (see
+// glyph-codepoints.ts), so an agent that cannot type a Nerd Font character can
+// still put one on screen.
+import { expandGlyphCodepoints } from './glyph-codepoints.js';
+const ATX_HEADING = /^(\s{0,3})(#{3,6})(?:[ \t]+|$)(.*?)([ \t]+#+[ \t]*)?$/;
+const FENCE_OPEN = /^\s{0,3}(`{3,}|~{3,})/;
+/** A line holding one tag and nothing else: `<name …>`, `</name>`, `<name/>`.
+ *  Attribute text may not contain angle brackets, so a tag whose value carries
+ *  a literal `>` stays untouched rather than being mis-split. */
+const XML_TAG_LINE = /^([ \t]{0,3})(<\/?)([A-Za-z][\w.:-]*)((?:[ \t]+[^<>]*?)?)(\/?)>[ \t]*$/;
+const XML_ATTRIBUTE = /([^\s=]+)(?:=("[^"]*"|'[^']*'|[^\s]*))?/g;
+/** Tags the HTML allowlist owns (see html-markdown.ts). A `<details>` block
+ *  that reaches this pass is one that failed validation there and is meant to
+ *  stay literal. */
+const HTML_ALLOWLIST_TAGS = new Set(['details', 'summary', 'kbd', 'mark']);
+// A constant-lightness ramp from warm yellow to cool blue, with saturation
+// deliberately reduced at each step so the hierarchy recedes rather than
+// becoming a tour of unrelated accent colors.
+const HEADING_COLORS = [
+    [232, 194, 104],
+    [207, 194, 145],
+    [181, 184, 174],
+    [157, 170, 180],
+    [135, 153, 164],
+    [116, 135, 147],
+];
+// Structural framing, not content. The hue relationships mirror the XML
+// highlighting pi already applies inside fenced code — blue tag name, duller
+// blue attribute, warm quoted value — at a lower brightness, because an
+// envelope tag wrapping prose should be scannable without competing with the
+// prose the way a code block does.
+const XML_PUNCTUATION = [104, 112, 124];
+const XML_NAME = [138, 166, 196];
+const XML_ATTRIBUTE_NAME = [124, 146, 164];
+const XML_VALUE = [168, 142, 118];
+/** Paint a fragment with a foreground color and restore only the foreground,
+ *  so a surrounding message style (background, weight) survives. */
+function paint(color, text) {
+    return `\x1b[38;2;${color[0]};${color[1]};${color[2]}m${text}\x1b[39m`;
+}
+function headingColor(level) {
+    const [r, g, b] = HEADING_COLORS[level - 1];
+    return (text) => `\x1b[1;38;2;${r};${g};${b}m${text}\x1b[22;39m`;
+}
+/** Style one ATX H3–H6 line. The Markdown markers are syntax, not content, so
+ *  omit them from the rendered line. */
+function styleHeadingLine(line) {
+    const match = ATX_HEADING.exec(line);
+    if (!match)
+        return undefined;
+    const [, indent, hashes, body] = match;
+    if (body === '')
+        return undefined;
+    return `${indent}${headingColor(hashes.length)(body)}`;
+}
+function styleAttributes(attributes) {
+    return attributes.replace(XML_ATTRIBUTE, (whole, name, value) => (value === undefined
+        ? paint(XML_ATTRIBUTE_NAME, whole)
+        : `${paint(XML_ATTRIBUTE_NAME, name)}${paint(XML_PUNCTUATION, '=')}${paint(XML_VALUE, value)}`));
+}
+/** Style a line that is exactly one XML tag, or return undefined to leave it. */
+function styleXmlTagLine(line) {
+    const match = XML_TAG_LINE.exec(line);
+    if (!match)
+        return undefined;
+    const [, indent, open, name, attributes, selfClose] = match;
+    if (HTML_ALLOWLIST_TAGS.has(name.toLowerCase()))
+        return undefined;
+    return indent
+        + paint(XML_PUNCTUATION, open)
+        + paint(XML_NAME, name)
+        + styleAttributes(attributes)
+        + paint(XML_PUNCTUATION, `${selfClose}>`);
+}
+/** Decorate a Markdown block for terminal rendering: heading hierarchy and XML
+ *  tag lines. Fenced examples remain literal Markdown, never decorated
+ *  terminal output. */
+export function styleAttachMarkdownSource(markdown) {
+    const lines = markdown.split('\n');
+    const out = [];
+    let fence;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const fenceMatch = FENCE_OPEN.exec(line);
+        if (fence !== undefined) {
+            if (fenceMatch?.[1][0] === fence)
+                fence = undefined;
+            out.push(line);
+            continue;
+        }
+        if (fenceMatch) {
+            fence = fenceMatch[1][0];
+            out.push(line);
+            continue;
+        }
+        const tag = styleXmlTagLine(line);
+        if (tag !== undefined) {
+            if (out.length > 0 && out[out.length - 1].trim() !== '')
+                out.push('');
+            out.push(tag);
+            if (lines[index + 1] !== undefined && lines[index + 1].trim() !== '')
+                out.push('');
+            continue;
+        }
+        out.push(styleHeadingLine(line) ?? line);
+    }
+    return out.join('\n');
+}
+/** Every source-text transform the viewer applies to a Markdown-bearing block,
+ *  in one place: heading and XML syntax, then glyph expansion. */
+function renderableText(markdown) {
+    return expandGlyphCodepoints(styleAttachMarkdownSource(markdown));
+}
+/** Copy a pi message for terminal rendering and decorate only Markdown-bearing
+ * text/thinking blocks. The broker's source event is never mutated. */
+export function styleAttachMessageMarkdown(message) {
+    if (typeof message !== 'object' || message === null || !('content' in message))
+        return message;
+    const candidate = message;
+    if (typeof candidate.content === 'string') {
+        return { ...candidate, content: renderableText(candidate.content) };
+    }
+    if (!Array.isArray(candidate.content))
+        return message;
+    return {
+        ...candidate,
+        content: candidate.content.map((part) => {
+            if (typeof part !== 'object' || part === null)
+                return part;
+            const block = part;
+            if (block.type === 'text' && typeof block.text === 'string') {
+                return { ...block, text: renderableText(block.text) };
+            }
+            if (block.type === 'thinking' && typeof block.thinking === 'string') {
+                return { ...block, thinking: renderableText(block.thinking) };
+            }
+            return part;
+        }),
+    };
+}
+/** Copy an expanded pi summary without changing its persisted source. */
+export function styleAttachSummaryMarkdown(message) {
+    return { ...message, summary: renderableText(message.summary) };
+}

package/dist/clients/attach/session/bindings.js

@@ -5,7 +5,7 @@
 // tmux installer binds from (`core/keybindings`), never from ad-hoc key
 // literals, so a user's rebind is honored by the viewer and tmux alike.
 import { matchesKey } from '@earendil-works/pi-tui';
-import { ATTACH_CONTROL_BINDINGS, formatBinding, matchesPiTuiInput, } from '../../../core/keybindings/index.js';
+import { ATTACH_CONTROL_BINDINGS, formatBinding, matchesPiTuiInput, normalizeShiftedMeta, } from '../../../core/keybindings/index.js';
 export const ATTACH_VIEWPORT_BINDINGS = [
     'crtr.attach.scroll.up', 'crtr.attach.scroll.down',
     'crtr.attach.scroll.page-up', 'crtr.attach.scroll.page-down',
@@ -15,7 +15,10 @@ export const ATTACH_VIEWPORT_BINDINGS = [
 ];
 export { inboxOpenHint } from '../../../core/keybindings/index.js';
 export function matchesAttachBinding(bindings, id, data) {
-    return matchesPiTuiInput(bindings, id, data, (input, gesture) => matchesKey(input, gesture));
+    // Match the normalized chunk, never the raw one: a terminal that sends Option
+    // as a meta prefix spells Alt+Shift+M in a form pi-tui rejects. Only matching
+    // reads the rewrite — unclaimed input reaches the editor exactly as typed.
+    return matchesPiTuiInput(bindings, id, normalizeShiftedMeta(data), (input, gesture) => matchesKey(input, gesture));
 }
 export function dispatchAttachAction(id, actions) {
     actions[id]();