tui-cap 0.1.0

package/dist/input.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputTracker = exports.INPUT_SCHEMA_VERSION = void 0;
+exports.inputPathFor = inputPathFor;
+exports.countPrintable = countPrintable;
+exports.writeInput = writeInput;
+exports.readInput = readInput;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+exports.INPUT_SCHEMA_VERSION = 1;
+/** Sibling sidecar path for a capture file: `foo.ans` -> `foo.input.json`. */
+function inputPathFor(captureFile) {
+    const dir = node_path_1.default.dirname(captureFile);
+    const base = node_path_1.default.basename(captureFile, node_path_1.default.extname(captureFile));
+    return node_path_1.default.join(dir, `${base}.input.json`);
+}
+/**
+ * Count the printable characters in an input burst, ignoring escape sequences
+ * and control bytes so only real text insertions are tallied.
+ *
+ * Terminal stdin carries far more than glyphs: arrow keys and function keys
+ * arrive as CSI/SS3 escape sequences (`ESC [ … final`, `ESC O x`), Enter is a
+ * carriage return, Backspace/Delete are control bytes, and a paste is wrapped in
+ * bracketed-paste markers (`ESC [ 200 ~` … `ESC [ 201 ~`). We skip every escape
+ * sequence and C0 control (and DEL), counting only Unicode scalar values at or
+ * above U+0020 — which includes the space bar and the printable contents of a
+ * paste, so a paste registers as typing too.
+ */
+function countPrintable(input) {
+    const s = typeof input === 'string' ? input : input.toString('utf8');
+    let n = 0;
+    let i = 0;
+    while (i < s.length) {
+        const code = s.codePointAt(i);
+        const len = code > 0xffff ? 2 : 1; // surrogate pair vs BMP
+        if (code === 0x1b) {
+            // Escape sequence — consume it whole so its payload isn't miscounted.
+            i++;
+            if (i < s.length && s[i] === '[') {
+                // CSI: run until a final byte in 0x40–0x7e (covers arrows, Home/End,
+                // and the 200~/201~ bracketed-paste markers).
+                i++;
+                while (i < s.length) {
+                    const c = s.charCodeAt(i);
+                    i++;
+                    if (c >= 0x40 && c <= 0x7e)
+                        break;
+                }
+            }
+            else if (i < s.length && s[i] === 'O') {
+                i += 2; // SS3: ESC O x (e.g. F1–F4)
+            }
+            else if (i < s.length) {
+                i++; // ESC + one byte (Alt-modified key)
+            }
+            continue;
+        }
+        if (code < 0x20 || code === 0x7f) {
+            i += len; // C0 control (Tab, Enter, Backspace…) or DEL — not a glyph
+            continue;
+        }
+        n++;
+        i += len;
+    }
+    return n;
+}
+/**
+ * Accumulates keystroke bursts while a capture streams in. Construct it with the
+ * SAME start time as the recording's {@link TimingTracker} so event times and
+ * frame appearance times share a clock. Call {@link mark} with each chunk of
+ * user input as it's forwarded to the child; bursts with no printable text are
+ * ignored. {@link build} returns the serializable sidecar.
+ */
+class InputTracker {
+    events = [];
+    startMs;
+    constructor(startMs = Date.now()) {
+        this.startMs = startMs;
+    }
+    /** Record an input burst sent at time `now`; no-op if it's non-printable. */
+    mark(input, now = Date.now()) {
+        const count = countPrintable(input);
+        if (count <= 0)
+            return;
+        this.events.push([Math.max(0, now - this.startMs), count]);
+    }
+    /** Number of printable-burst events recorded so far. */
+    get length() {
+        return this.events.length;
+    }
+    build() {
+        return {
+            schemaVersion: exports.INPUT_SCHEMA_VERSION,
+            startedAt: new Date(this.startMs).toISOString(),
+            events: this.events,
+        };
+    }
+}
+exports.InputTracker = InputTracker;
+/** Write the input sidecar next to `captureFile`. Returns the sidecar path. */
+async function writeInput(captureFile, input) {
+    const out = inputPathFor(captureFile);
+    await (0, promises_1.writeFile)(out, `${JSON.stringify(input)}\n`, 'utf8');
+    return out;
+}
+/**
+ * Read a capture's input sidecar, or null if it's missing or unusable. Never
+ * throws — a missing/garbled sidecar simply means "no keystroke data", so the
+ * typing features quietly no-op for that recording.
+ */
+async function readInput(captureFile) {
+    try {
+        const raw = await (0, promises_1.readFile)(inputPathFor(captureFile), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.events))
+            return null;
+        const events = parsed.events.filter((e) => Array.isArray(e) &&
+            e.length === 2 &&
+            Number.isFinite(e[0]) &&
+            Number.isFinite(e[1]) &&
+            e[1] > 0);
+        if (events.length === 0)
+            return null;
+        return {
+            schemaVersion: parsed.schemaVersion ?? exports.INPUT_SCHEMA_VERSION,
+            startedAt: parsed.startedAt ?? '',
+            events,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/meta.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.META_SCHEMA_VERSION = void 0;
+exports.metaPathFor = metaPathFor;
+exports.writeMeta = writeMeta;
+exports.readMeta = readMeta;
+exports.terminalSize = terminalSize;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+exports.META_SCHEMA_VERSION = 1;
+/** Sibling sidecar path for a capture file: `foo.ans` -> `foo.meta.json`. */
+function metaPathFor(captureFile) {
+    const dir = node_path_1.default.dirname(captureFile);
+    const base = node_path_1.default.basename(captureFile, node_path_1.default.extname(captureFile));
+    return node_path_1.default.join(dir, `${base}.meta.json`);
+}
+/** Write the sidecar next to `captureFile`. Returns the sidecar path. */
+async function writeMeta(captureFile, meta) {
+    const out = metaPathFor(captureFile);
+    await (0, promises_1.writeFile)(out, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+    return out;
+}
+/**
+ * Read a capture's sidecar, or null if it's missing or unusable. Never throws —
+ * a missing/garbled sidecar simply means "fall back to defaults".
+ */
+async function readMeta(captureFile) {
+    try {
+        const raw = await (0, promises_1.readFile)(metaPathFor(captureFile), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.cols === 'number' &&
+            Number.isFinite(parsed.cols) &&
+            typeof parsed.rows === 'number' &&
+            Number.isFinite(parsed.rows)) {
+            return {
+                schemaVersion: parsed.schemaVersion ?? exports.META_SCHEMA_VERSION,
+                cols: parsed.cols,
+                rows: parsed.rows,
+                capturedAt: parsed.capturedAt ?? '',
+                command: parsed.command,
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Current terminal size, with a sensible fallback when stdout isn't a TTY. */
+function terminalSize(fallbackCols = 120, fallbackRows = 50) {
+    return {
+        cols: process.stdout.columns ?? fallbackCols,
+        rows: process.stdout.rows ?? fallbackRows,
+    };
+}

package/dist/palette.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THEMES = exports.ANSI_16 = exports.ANSI_PALETTES = void 0;
+exports.packedRgbToHex = packedRgbToHex;
+exports.paletteToHex = paletteToHex;
+/**
+ * The 16 base ANSI colors per theme, mapping ANSI palette indices 0–15 to
+ * GitHub's brand terminal hues so captured output reproduces brand-correct.
+ *
+ * Source of truth: @primer/primitives v11.9.0, the `--ansi-*` functional tokens
+ * (`dist/css/functional/themes/{dark,light}.css`). Standard ANSI-16 order:
+ * black, red, green, yellow, blue, magenta, cyan, white, then the 8 bright
+ * variants. Values are copied verbatim from those tokens — do not eyeball.
+ *
+ * Provenance note (verified against github/copilot-agent-runtime): the Copilot
+ * CLI itself does NOT hardcode GitHub-brand ANSI hexes. It queries the live
+ * terminal for its palette (OSC 4/10/11) and emits 24-bit truecolor built from
+ * that, falling back to the Windows-Terminal "Campbell" scheme only when the
+ * query fails. Real Copilot captures are therefore 100% truecolor and round-trip
+ * exactly through `packedRgbToHex` — this ANSI-16 table is the brand-correct
+ * fallback for streams that DO emit ANSI-16/256 (other CLIs, no-truecolor
+ * terminals). We deliberately choose the Primer brand palette here, not Campbell,
+ * because this is a GitHub brand tool.
+ */
+exports.ANSI_PALETTES = {
+    dark: [
+        '#2f3742', // 0  black
+        '#ff7b72', // 1  red
+        '#3fb950', // 2  green
+        '#d29922', // 3  yellow
+        '#58a6ff', // 4  blue
+        '#be8fff', // 5  magenta
+        '#39c5cf', // 6  cyan
+        '#f0f6fc', // 7  white
+        '#656c76', // 8  bright black
+        '#ffa198', // 9  bright red
+        '#56d364', // 10 bright green
+        '#e3b341', // 11 bright yellow
+        '#79c0ff', // 12 bright blue
+        '#d2a8ff', // 13 bright magenta
+        '#56d4dd', // 14 bright cyan
+        '#ffffff', // 15 bright white
+    ],
+    light: [
+        '#1f2328', // 0  black
+        '#cf222e', // 1  red
+        '#116329', // 2  green
+        '#4d2d00', // 3  yellow
+        '#0969da', // 4  blue
+        '#8250df', // 5  magenta
+        '#1b7c83', // 6  cyan
+        '#59636e', // 7  white
+        '#393f46', // 8  bright black
+        '#a40e26', // 9  bright red
+        '#1a7f37', // 10 bright green
+        '#633c01', // 11 bright yellow
+        '#218bff', // 12 bright blue
+        '#a475f9', // 13 bright magenta
+        '#3192aa', // 14 bright cyan
+        '#818b98', // 15 bright white
+    ],
+};
+/** Back-compat alias for the dark ANSI-16 set (the original single export). */
+exports.ANSI_16 = exports.ANSI_PALETTES.dark;
+/**
+ * Window/canvas colors per theme. Sourced from @primer/primitives v11.9.0
+ * functional tokens: background = `--bgColor-default`, foreground =
+ * `--fgColor-default`, chrome (title bar) = `--bgColor-muted`, border =
+ * `--borderColor-default`.
+ */
+exports.THEMES = {
+    dark: {
+        background: '#0d1117',
+        foreground: '#f0f6fc',
+        chrome: '#151b23',
+        border: '#3d444d',
+    },
+    light: {
+        background: '#ffffff',
+        foreground: '#1f2328',
+        chrome: '#f6f8fa',
+        border: '#d1d9e0',
+    },
+};
+const CUBE_LEVELS = [0, 95, 135, 175, 215, 255];
+function toHex(r, g, b) {
+    const h = (n) => n.toString(16).padStart(2, '0');
+    return `#${h(r)}${h(g)}${h(b)}`;
+}
+/** Convert an xterm packed RGB integer (0xRRGGBB) to a #rrggbb string. */
+function packedRgbToHex(value) {
+    return toHex((value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff);
+}
+/**
+ * Convert a 0–255 xterm palette index to a #rrggbb string.
+ *
+ * Indices 0–15 are theme-dependent (ANSI-16, brand-themed). The 6×6×6 color
+ * cube (16–231) and the grayscale ramp (232–255) are fixed by the xterm-256
+ * spec and identical across themes. Defaults to the dark palette for
+ * back-compat with callers that don't pass a theme.
+ */
+function paletteToHex(index, theme = 'dark') {
+    if (index < 16)
+        return exports.ANSI_PALETTES[theme][index];
+    if (index < 232) {
+        const i = index - 16;
+        return toHex(CUBE_LEVELS[Math.floor(i / 36) % 6], CUBE_LEVELS[Math.floor(i / 6) % 6], CUBE_LEVELS[i % 6]);
+    }
+    const gray = 8 + (index - 232) * 10;
+    return toHex(gray, gray, gray);
+}