@joewinke/jatui 0.1.25 → 0.1.26

package/dist/components/session-nav/transcriptModel.js

@@ -0,0 +1,285 @@
+/**
+ * transcriptModel.ts — transcript → linked (transcript items ↔ signal nodes) model
+ * for the session navigator. Extracted from sankey/sankeyData.ts (jat-w8tgz.1).
+ *
+ * THE CONCEPT (from ~/Documents/many_to_one.mp4): a two-column linked view like
+ * an academic article + its citations. LEFT = the session transcript (prose),
+ * RIGHT = the signal events (the "references"). Curved ribbons connect spans of
+ * the transcript to the signal they produced, and ink up as you scroll/hover.
+ *
+ * THE ANCHORING TRICK: a JAT agent emits state by running `jat-signal <type> …`,
+ * which appears in Claude's transcript as a Bash tool call. So we scan the
+ * transcript for those calls and treat each as a signal-emission boundary. Each
+ * signal then "owns" the run of transcript that led up to it — the genuine
+ * many-to-one mapping. The jat-signal lines themselves are plumbing, so we
+ * consume them as boundaries and do NOT render them.
+ *
+ * COMPACTION: raw transcript lines are noisy (every tool result, every "file
+ * updated successfully" notice). We group lines into ITEMS:
+ *   - prompt    — a user message (shown in full; it's the human's intent)
+ *   - assistant — the agent's prose (shown in full; it's the narrative)
+ *   - action    — a tool call, with its result body tucked into `detail` so the
+ *                 transcript shows just the headline by default and the body is
+ *                 a drill-down. This is what keeps the left column readable.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+export function rawTypeToState(raw) {
+    switch (raw) {
+        case 'needs_input':
+            return 'needs-input';
+        case 'review':
+            return 'ready-for-review';
+        case 'complete':
+        case 'completed':
+            return 'completed';
+        default:
+            return raw; // starting, working, completing, paused, idle pass through
+    }
+}
+/** Detect a `jat-signal <type> '<json>'` invocation in a tool-call body. */
+function parseSignalBody(body) {
+    var m = body.match(/jat-signal\s+(starting|working|needs_input|review|completing|complete|completed|paused|idle)\b/);
+    if (!m)
+        return null;
+    var label = '';
+    var pick = body.match(/"(?:approach|question|reviewFocus|currentStep|summary|reason|taskTitle)"\s*:\s*"([^"]{3,90})/);
+    if (pick)
+        label = pick[1];
+    return { rawType: m[1], label: label };
+}
+/** Build the linked model from rendered transcript lines. */
+export function buildLinkedSession(lines) {
+    var items = [];
+    var emits = [];
+    var cur = null;
+    var flush = function () {
+        if (cur) {
+            items.push(__assign(__assign({ id: items.length }, cur), { signalId: null }));
+            cur = null;
+        }
+    };
+    for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+        var line = lines_1[_i];
+        if (!line.trim()) {
+            flush();
+            continue;
+        } // blank ends a block
+        if (line.startsWith('› ')) {
+            flush();
+            cur = { kind: 'prompt', headline: line.slice(2), detail: [], srcLines: 1 };
+            continue;
+        }
+        if (line.startsWith('⏺ ')) {
+            var body = line.slice(2);
+            var sig = parseSignalBody(body);
+            if (sig) {
+                // signal emission = boundary; consume it, don't render as an item
+                flush();
+                emits.push({ afterIdx: items.length - 1, rawType: sig.rawType, label: sig.label });
+                continue;
+            }
+            flush();
+            cur = { kind: 'action', headline: body, detail: [], srcLines: 1 };
+            continue;
+        }
+        if (line.startsWith('  ⎿ ')) {
+            var body = line.slice(4);
+            if (cur) {
+                cur.detail.push(body);
+                cur.srcLines++;
+            }
+            continue;
+        }
+        if (line.startsWith('   ')) {
+            // continuation: tool detail for actions, prose for prompt/assistant
+            var body = line.trimStart();
+            if (cur && cur.kind === 'action') {
+                cur.detail.push(body);
+                cur.srcLines++;
+            }
+            else if (cur) {
+                cur.headline += '\n' + body;
+                cur.srcLines++;
+            }
+            continue;
+        }
+        // plain assistant prose
+        if (cur && cur.kind === 'assistant') {
+            cur.headline += '\n' + line;
+            cur.srcLines++;
+        }
+        else {
+            flush();
+            cur = { kind: 'assistant', headline: line, detail: [], srcLines: 1 };
+        }
+    }
+    flush();
+    // Build signal nodes from emission boundaries.
+    var signals = [];
+    var prevBoundary = -1;
+    emits.forEach(function (e, i) {
+        var rowStart = Math.max(0, prevBoundary + 1);
+        var rowEnd = Math.max(rowStart, e.afterIdx);
+        var lineCount = 0;
+        for (var k = rowStart; k <= rowEnd && k < items.length; k++)
+            lineCount += items[k].srcLines;
+        signals.push({
+            id: "sig-".concat(i),
+            state: rawTypeToState(e.rawType),
+            rawType: e.rawType,
+            label: e.label,
+            rowStart: rowStart,
+            rowEnd: rowEnd,
+            lineCount: Math.max(1, lineCount),
+            // No WorkBlock substrate data in the raw-lines path
+            blockId: null,
+            summary: null,
+            filesTouched: [],
+            commits: [],
+            linesAdded: 0,
+            linesRemoved: 0
+        });
+        prevBoundary = e.afterIdx;
+    });
+    for (var _a = 0, signals_1 = signals; _a < signals_1.length; _a++) {
+        var sig = signals_1[_a];
+        for (var k = sig.rowStart; k <= sig.rowEnd && k < items.length; k++) {
+            items[k].signalId = sig.id;
+        }
+    }
+    return { items: items, signals: signals };
+}
+/**
+ * Build a LinkedSession from the WorkBlock substrate (B1).
+ *
+ * This is the preferred path for live sessions — it uses the richer data from
+ * `getSessionWork` (A1) including per-block summaries (A2) and file lists (A3)
+ * instead of re-parsing transcript lines.
+ *
+ * The `items` array from the server is used directly as `TranscriptItem[]` since
+ * both shapes share `id`, `kind`, `headline`, `detail`, `srcLines` with the
+ * `signalId` replaced by `blockId → signalId` mapping done here.
+ *
+ * @param blocks  WorkBlock array from `/api/work/[sessionId]/navigator`
+ * @param items   WorkTranscriptItem array from the same endpoint
+ */
+export function buildLinkedSessionFromWork(blocks, items) {
+    // Map WorkTranscriptItem → TranscriptItem (blockId → signalId mapping happens after)
+    var transcriptItems = items.map(function (it) { return ({
+        id: it.id,
+        kind: it.kind,
+        headline: it.headline,
+        detail: it.detail,
+        srcLines: it.srcLines,
+        signalId: null // filled in below
+    }); });
+    // Map WorkBlock → SignalNode
+    var signals = blocks.map(function (blk) {
+        var _a, _b, _c;
+        return ({
+            id: blk.id,
+            state: rawTypeToState(blk.signal.type),
+            rawType: blk.signal.type,
+            label: blk.signal.label,
+            rowStart: blk.itemRange.start,
+            rowEnd: blk.itemRange.end,
+            lineCount: blk.lineCount,
+            // WorkBlock substrate fields
+            blockId: blk.id,
+            summary: blk.summary,
+            filesTouched: blk.filesTouched,
+            commits: (_a = blk.commits) !== null && _a !== void 0 ? _a : [],
+            linesAdded: (_b = blk.linesAdded) !== null && _b !== void 0 ? _b : 0,
+            linesRemoved: (_c = blk.linesRemoved) !== null && _c !== void 0 ? _c : 0
+        });
+    });
+    // Assign signalId to transcript items via block ownership
+    for (var _i = 0, signals_2 = signals; _i < signals_2.length; _i++) {
+        var sig = signals_2[_i];
+        for (var k = sig.rowStart; k <= sig.rowEnd && k < transcriptItems.length; k++) {
+            transcriptItems[k].signalId = sig.id;
+        }
+    }
+    return { items: transcriptItems, signals: signals };
+}
+/**
+ * A baked, realistic sample so /sankey always demos beautifully even with no live
+ * session. Authored as raw transcript lines with real `jat-signal` calls, so it
+ * flows through the EXACT same parser as live data.
+ */
+export var SAMPLE_TRANSCRIPT_LINES = [
+    '',
+    '› /jat:start GentleCoast jat-7h2k',
+    '⏺ Bash(get-current-session-id)',
+    '  ⎿ 4f9c1a2e-7b3d-4c8a-9e1f-2a6b8c0d4e5f',
+    '⏺ Bash(jat-signal starting \'{"agentName":"GentleCoast","taskTitle":"Add password reset flow"}\')',
+    '  ⎿ Signal: starting (agent: GentleCoast, task: jat-7h2k)',
+    '',
+    'I\'ll implement the password reset flow. Let me first read the existing auth module',
+    'to understand the current login + token handling before adding the reset endpoints.',
+    '⏺ Read(src/lib/auth/login.ts)',
+    '  ⎿ export async function login(email, password) {',
+    '       const user = await findUser(email);',
+    '       … +48 more lines',
+    '⏺ Read(src/lib/auth/tokens.ts)',
+    '  ⎿ export function signToken(payload) {',
+    '       return jwt.sign(payload, SECRET, { expiresIn: \'15m\' });',
+    '       … +22 more lines',
+    '⏺ Bash(jat-signal working \'{"taskId":"jat-7h2k","approach":"Add reset-request + reset-confirm endpoints, reuse signToken with a short-lived scope"}\')',
+    '  ⎿ Signal: working (task: jat-7h2k)',
+    '',
+    'The token helper already supports short expiries. I\'ll add a reset-scoped token',
+    'and two endpoints: one to request a reset email, one to confirm with the token.',
+    '⏺ Write(src/routes/api/auth/reset-request/+server.ts)',
+    '  ⎿ Wrote 41 lines',
+    '⏺ Write(src/routes/api/auth/reset-confirm/+server.ts)',
+    '  ⎿ Wrote 56 lines',
+    '⏺ Edit(src/lib/auth/tokens.ts)',
+    '  ⎿ Added signResetToken() with a 30-minute reset scope',
+    '⏺ Bash(npm run check)',
+    '  ⎿ svelte-check found 0 errors and 0 warnings',
+    '',
+    'Both endpoints compile cleanly. One open question before I wire the email send:',
+    'should reset links expire in 30 minutes, or match the 15-minute access-token window?',
+    '⏺ Bash(jat-signal needs_input \'{"taskId":"jat-7h2k","question":"Reset link expiry: 30 min or match the 15-min access token?"}\')',
+    '  ⎿ Signal: needs_input (task: jat-7h2k)',
+    '',
+    '› 30 minutes is fine — people read email slowly.',
+    '',
+    'Got it — keeping the 30-minute reset scope. Now wiring the email send through',
+    'the existing Resend helper and adding a rate-limit guard so the endpoint can\'t be',
+    'used to spam a victim\'s inbox.',
+    '⏺ Bash(jat-signal working \'{"taskId":"jat-7h2k","approach":"Wire Resend email + add per-email rate limit on reset-request"}\')',
+    '  ⎿ Signal: working (task: jat-7h2k)',
+    '⏺ Edit(src/routes/api/auth/reset-request/+server.ts)',
+    '  ⎿ Sends reset email via sendEmail(); added 3-per-hour rate limit',
+    '⏺ Bash(npm run test -- auth)',
+    '  ⎿ 12 passing (auth reset flow covered)',
+    '',
+    'All tests pass. The flow is complete: request → email → confirm → new password.',
+    'Summarizing for review.',
+    '⏺ Bash(jat-signal review \'{"taskId":"jat-7h2k","summary":["Added reset-request + reset-confirm endpoints","30-min reset-scoped token","Resend email + 3/hr rate limit","12 tests passing"]}\')',
+    '  ⎿ Signal: review (task: jat-7h2k)',
+    '',
+    '🔍 READY FOR REVIEW: jat-7h2k — password reset flow implemented, tested, rate-limited.',
+    '',
+    '› /jat:complete',
+    '⏺ Bash(jat-step committing --task jat-7h2k)',
+    '  ⎿ Committed: feat(jat-7h2k): add password reset flow',
+    '⏺ Bash(jat-signal complete \'{"taskId":"jat-7h2k","summary":"Shipped password reset flow"}\')',
+    '  ⎿ Signal: complete (task: jat-7h2k)',
+    ''
+];
+export function sampleLinkedSession() {
+    return buildLinkedSession(SAMPLE_TRANSCRIPT_LINES);
+}

package/dist/data/emojis.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Full Unicode emoji dataset organized by category.
+ * Each emoji has a character and searchable name.
+ * Based on Unicode CLDR emoji ordering, minus most flags.
+ */
+export interface EmojiEntry {
+    char: string;
+    name: string;
+}
+export interface EmojiGroup {
+    label: string;
+    emojis: EmojiEntry[];
+}
+export declare const EMOJI_DATA: EmojiGroup[];
+/** Flat array of all emojis for search */
+export declare const ALL_EMOJIS: EmojiEntry[];
+/** Search emojis by name, returns matching entries */
+export declare function searchEmojis(query: string): EmojiEntry[];