cli-jaw 2.2.8 → 2.2.10

package/dist/src/messaging/chunk.js

@@ -0,0 +1,376 @@
+// ─── Shared Message Chunking ─────────────────────────
+// One splitter for every channel. Promoted from src/slack/format.ts, which is
+// the only implementation that survived an adversarial audit; Discord and
+// Telegram each grew their own and each lost content in a different way.
+//
+// The guarantees, in order of importance:
+//   1. No content loss. Chunks concatenate back to the input, apart from the
+//      ``` markers deliberately injected to keep a split code block closed.
+//   2. No split surrogate pairs. Half an emoji is worse than an oversized
+//      chunk, and a zero-width cut loops forever.
+//   3. Balanced fences. Agent output is code-heavy; a split inside a fence
+//      renders the remainder as prose on every channel that speaks markdown.
+/** Below this, fence-aware wrapping cannot fit; fall back to a plain split. */
+const MIN_FENCE_AWARE_LIMIT = 24;
+/**
+ * A language tag longer than this is not a real language. Truncating bounds
+ * the reserve computation: an unbounded tag could consume the whole budget
+ * and leave no room for payload.
+ */
+const MAX_FENCE_LANG = 20;
+/**
+ * Bytes a chunk must reserve to reopen an inherited fence and close its own.
+ * NOT a constant: reopening as ```typescript costs 14, not the 4 a bare fence
+ * costs, and a fixed reserve pushes the chunk past the caller's limit.
+ */
+export function fenceReserve(lang, marker = '```') {
+    return `${marker}${lang}\n`.length + `\n${marker}`.length;
+}
+/**
+ * Fences are LINE constructs: the delimiter must start a line (up to three
+ * spaces of indent), and a closer must be at least as long as its opener and
+ * carry no info string.
+ *
+ * Counting every ``` in the text instead treats a backtick run inside a code
+ * block — `const marker = "```";` is ordinary agent output — as a closer, and
+ * ships the remainder of the message as prose.
+ *
+ * SCOPE: top-level fences only. A fence nested in a block quote or list item
+ * ("> ```ts", "- ```ts") is not tracked, so such a block splits as prose
+ * rather than being reopened. Repairing it would mean carrying the container
+ * prefix into every injected marker, which is a larger change than the defect
+ * warrants — agent output puts code at the top level.
+ */
+const FENCE_LINE = /^ {0,3}(`{3,}|~{3,})[ \t]*([^\n`]*)$/;
+/** True when the text contains a line-start fence of any delimiter. */
+export function hasFence(text) {
+    return FENCE_ANYWHERE.test(text);
+}
+const FENCE_ANYWHERE = /^ {0,3}(?:`{3,}|~{3,})/m;
+/** The fence still open after `text`, or null when everything is closed. */
+export function scanOpenFence(text, initial = null, 
+/**
+ * False when `text` continues a line rather than starting one. A chunker
+ * hands us slices, and a delimiter that sits mid-line in the source must
+ * not become a fence just because a slice happens to begin there.
+ */
+atLineStart = true) {
+    let open = initial;
+    const lines = text.split('\n');
+    for (const [index, line] of lines.entries()) {
+        if (index === 0 && !atLineStart)
+            continue;
+        const m = FENCE_LINE.exec(line);
+        if (!m)
+            continue;
+        const marker = m[1] ?? '';
+        const info = (m[2] ?? '').trim();
+        if (open) {
+            // A closer uses the same character, is at least as long, and has
+            // no info string. Anything else is content inside the block.
+            const sameChar = marker[0] === open.marker[0];
+            if (sameChar && marker.length >= open.marker.length && info === '')
+                open = null;
+            continue;
+        }
+        open = { marker, lang: fenceLangOf(info) };
+    }
+    return open;
+}
+function fenceLangOf(info) {
+    return /^[A-Za-z0-9_+#.-]*$/.test(info) ? info.slice(0, MAX_FENCE_LANG) : '';
+}
+/** Language tag of the fence left open by `text`, or '' when none is open. */
+export function trailingFenceLang(text) {
+    return scanOpenFence(text)?.lang ?? '';
+}
+/**
+ * Split at a code-point boundary so a cut never separates a surrogate pair.
+ * When backing off would produce an empty chunk (a limit so small that a
+ * single astral character does not fit), advance instead: emitting one
+ * slightly oversized chunk is better than shipping half an emoji, and better
+ * than looping forever on a zero-length cut.
+ */
+export function safeCut(text, index) {
+    if (index >= text.length)
+        return text.length;
+    const code = text.charCodeAt(index);
+    const splitsPair = code >= 0xDC00 && code <= 0xDFFF;
+    if (!splitsPair)
+        return index;
+    return index > 1 ? index - 1 : index + 1;
+}
+/**
+ * Split text into chunks of at most `limit` characters WITHOUT losing content.
+ * Prefers newline boundaries; the newline stays with the preceding chunk so
+ * chunks concatenate back to the input exactly.
+ */
+export function splitPreservingContent(text, limit) {
+    const out = [];
+    let rest = text;
+    while (rest.length > limit) {
+        // Keep the newline in this chunk (+1) rather than dropping it.
+        const nl = rest.lastIndexOf('\n', limit - 1);
+        let cut = nl > 0 ? nl + 1 : safeCut(rest, limit);
+        // A zero cut would never consume input. Take one whole code point.
+        if (cut <= 0)
+            cut = safeCut(rest, Math.max(1, Math.min(limit, rest.length)));
+        if (cut <= 0)
+            cut = Math.min(2, rest.length);
+        out.push(rest.slice(0, cut));
+        rest = rest.slice(cut);
+    }
+    if (rest.length > 0)
+        out.push(rest);
+    return out;
+}
+/**
+ * Split for a channel that renders ``` code fences.
+ *
+ * Content is never lost: chunks concatenate back to the input apart from the
+ * ``` markers injected to keep each chunk's code block closed.
+ */
+export function chunkFenceAware(text, limit) {
+    if (!text)
+        return [text];
+    const cap = Math.max(1, Math.floor(limit));
+    if (text.length <= cap)
+        return [text];
+    // No fence in the input means no fence can straddle a boundary, so
+    // reserving room for injected markers only wastes budget — and a wasted
+    // budget costs the user a whole extra outbound message. The check goes
+    // through the lexer so a ~~~ block is not silently sent down the plain
+    // path, and an inline ``` run does not force the fence path.
+    if (!hasFence(text))
+        return splitPreservingContent(text, cap);
+    // Too small to wrap anything in fences — split plainly rather than spin.
+    if (cap < MIN_FENCE_AWARE_LIMIT)
+        return splitPreservingContent(text, cap);
+    // Reserve for the worst case this text can produce, so a piece can always
+    // carry its reopener and closer. Using the widest tag present keeps the
+    // pieces uniform; per-piece reserve would need the split to already exist.
+    const worst = widestFenceOpener(text);
+    const reserve = fenceReserve(worst.lang, worst.marker);
+    // A pathological tag could eat the whole budget. Fall back to bare fences
+    // rather than emit zero-payload pieces and never terminate.
+    const usableReserve = reserve < cap ? reserve : fenceReserve('');
+    const budget = Math.max(1, cap - usableReserve);
+    // Every piece is produced from the ORIGINAL text and strictly consumes it,
+    // so termination does not depend on how many fences we inject afterwards.
+    const rawPieces = splitPreservingContent(text, budget);
+    // A piece holding only fence markers and whitespace would post as an empty
+    // code block. MERGE it forward into the next piece rather than dropping it
+    // — skipping it silently deleted the source's own blank lines.
+    // Merging must not push a piece past the budget, or the injected fences
+    // would carry it over the caller's limit.
+    const pieces = [];
+    let carry = '';
+    for (const piece of rawPieces) {
+        const candidate = carry + piece;
+        if (candidate.length > budget) {
+            // Cannot merge without overflowing: emit what we have separately.
+            if (carry)
+                pieces.push(carry);
+            pieces.push(piece);
+            carry = '';
+            continue;
+        }
+        if (candidate.replace(/```/g, '').trim() === '') {
+            carry = candidate;
+            continue;
+        }
+        pieces.push(candidate);
+        carry = '';
+    }
+    if (carry) {
+        const last = pieces[pieces.length - 1];
+        if (last !== undefined && last.length + carry.length <= budget) {
+            pieces[pieces.length - 1] = last + carry;
+        }
+        else {
+            pieces.push(carry);
+        }
+    }
+    const out = closeAndReopen(pieces, reserve < cap, null, usableReserve);
+    return out.length > 0 ? out : [text];
+}
+/**
+ * Close a fence a piece leaves open and reopen it on the next piece, so every
+ * chunk renders as code on its own. `keepLang` is false only when reserving
+ * for the tag would not fit; highlighting is sacrificed before the size limit.
+ *
+ * Shared with the Telegram rich path so both agree on fence repair, and so a
+ * remainder re-split inherits the fence instead of starting as prose.
+ */
+export function closeAndReopen(pieces, keepLang = true, inheritedStart = null, 
+/**
+ * Largest reopener the caller budgeted for. A split can turn a run that was
+ * NOT an opener in the source ("````… x 한한````" carries extra backticks,
+ * so it is not a fence) into one, and reopening with that longer delimiter
+ * would blow the limit the caller sized for the source's own fences.
+ */
+maxReserve = Number.POSITIVE_INFINITY) {
+    // Pieces were built to fit the payload budget, so the seam fix must respect
+    // the same ceiling. Infer it rather than take another parameter: the pieces
+    // are the authority on what the splitter considered a full piece.
+    const budget = Math.max(...pieces.map((p) => p.length), 1);
+    const adjusted = avoidMidLineDelimiterAtSeam(pieces, budget);
+    const merged = mergeBareOpenerPieces(adjusted, budget);
+    const out = [];
+    let open = inheritedStart;
+    // A piece starts mid-line whenever the previous one did not end with a
+    // newline. Without this, a delimiter that sits inside a line in the source
+    // becomes a fence the moment a split lands just before it — inventing a
+    // code block and overshooting the caller's limit.
+    let atLineStart = true;
+    for (const piece of merged) {
+        const inherited = open;
+        // Scan the ORIGINAL piece: appending the closer below would make the
+        // scan report a balanced chunk and drop the carry-over.
+        //
+        // A reopener ends with a newline, so when one is prepended the piece
+        // DOES begin a line in the emitted chunk even if it continued one in
+        // the source. Reading the source state there left a real fence
+        // unrecognised and the chunk went out unclosed.
+        const startsLine = inherited !== null ? true : atLineStart;
+        const after = scanOpenFence(piece, inherited, startsLine);
+        let chunk = piece;
+        // KNOWN LIMITATION. A delimiter run longer than the budget cannot be
+        // reopened without breaking the caller's limit, so its block is not
+        // carried across chunks. Usually such a run is an artifact of the split
+        // (a backtick sequence that was not an opener in the source), but a
+        // genuine `-run wider than the budget is treated the same way.
+        //
+        // What still holds for those inputs: no content loss, no split
+        // surrogate, no chunk over the limit. What does not: the continuation
+        // will render as prose rather than code. Delivery beats formatting.
+        const repairable = (f) => f !== null && fenceReserve(f.lang, f.marker) <= maxReserve;
+        if (repairable(inherited)) {
+            const tag = keepLang ? inherited.lang : '';
+            chunk = `${inherited.marker}${tag}\n${chunk}`;
+        }
+        if (repairable(after)) {
+            chunk = chunk.endsWith('\n') ? `${chunk}${after.marker}` : `${chunk}\n${after.marker}`;
+        }
+        out.push(chunk);
+        // Carrying an unrepairable fence forward would make every later chunk
+        // try (and fail) to reopen it.
+        open = repairable(after) ? after : null;
+        // A reopener always ends with a newline, so a chunk we reopened still
+        // reflects the source's own line state at its end.
+        atLineStart = piece.endsWith('\n');
+    }
+    return out;
+}
+/**
+ * A piece holding nothing but an opening fence line would be emitted as an
+ * empty code block, and the next chunk would reopen the same fence — one
+ * wasted message carrying no content. Fold it into the piece that follows and
+ * push that piece's overflow down the line, exactly as the seam fix does.
+ */
+function mergeBareOpenerPieces(pieces, budget) {
+    const out = [...pieces];
+    // Bounded by the piece count. Merging can push a spill forward that is
+    // itself a bare opener, and rewinding to re-examine the same index let
+    // that repeat without end: a 43-character message never returned.
+    let merges = 0;
+    for (let i = 0; i < out.length - 1; i += 1) {
+        const piece = out[i] ?? '';
+        if (!/^ {0,3}(?:`{3,}|~{3,})[A-Za-z0-9_+#.-]*\n$/.test(piece))
+            continue;
+        if (merges >= pieces.length)
+            break;
+        merges += 1;
+        out[i + 1] = piece + (out[i + 1] ?? '');
+        out.splice(i, 1);
+        i -= 1;
+        for (let k = Math.max(i + 1, 0); k < out.length; k += 1) {
+            const current = out[k] ?? '';
+            if (current.length <= budget)
+                break;
+            const keep = safeCut(current, budget);
+            out[k] = current.slice(0, keep);
+            const spill = current.slice(keep);
+            if (k + 1 < out.length)
+                out[k + 1] = spill + (out[k + 1] ?? '');
+            else
+                out.push(spill);
+        }
+    }
+    return out;
+}
+/**
+ * A reopener ends with a newline, so whatever the next piece starts with lands
+ * at column zero. A delimiter run that sat MID-LINE in the source becomes a
+ * real fence there, closing the block a message early.
+ *
+ * Move one code point back across the seam so the run keeps company on its
+ * line. Rewriting the payload is not an option: these chunks must still
+ * concatenate back to the source.
+ */
+function avoidMidLineDelimiterAtSeam(pieces, budget) {
+    const out = [...pieces];
+    for (let i = 1; i < out.length; i += 1) {
+        const prev = out[i - 1] ?? '';
+        const piece = out[i] ?? '';
+        if (prev.endsWith('\n'))
+            continue;
+        if (!/^ {0,3}(?:`{3,}|~{3,})/.test(piece))
+            continue;
+        // Take a whole code point, and never empty the previous piece — that
+        // would stall the walk without fixing anything.
+        const low = prev.charCodeAt(prev.length - 1);
+        const step = low >= 0xDC00 && low <= 0xDFFF && prev.length >= 2 ? 2 : 1;
+        if (prev.length <= step)
+            continue;
+        // The receiving piece is usually already full, so growing it would push
+        // the chunk past the limit. Push the overflow down the line instead;
+        // each piece keeps at most `budget`, and the tail grows a new piece if
+        // needed. Content is conserved — nothing is added or dropped, only
+        // moved.
+        out[i - 1] = prev.slice(0, prev.length - step);
+        out[i] = prev.slice(prev.length - step) + piece;
+        for (let k = i; k < out.length; k += 1) {
+            const current = out[k] ?? '';
+            if (current.length <= budget)
+                break;
+            const keep = safeCut(current, budget);
+            out[k] = current.slice(0, keep);
+            const spill = current.slice(keep);
+            if (k + 1 < out.length)
+                out[k + 1] = spill + (out[k + 1] ?? '');
+            else
+                out.push(spill);
+        }
+    }
+    return out;
+}
+/**
+ * Widest fence opener in the text, for reserve sizing. `initial` lets a caller
+ * account for a fence inherited from earlier content: the remainder may close
+ * it and open a WIDER one, and missing that overshoots the limit.
+ */
+export function widestFenceOpener(text, initial = null) {
+    let widest = initial ?? { marker: '```', lang: '' };
+    let open = initial;
+    for (const line of text.split('\n')) {
+        const m = FENCE_LINE.exec(line);
+        if (!m)
+            continue;
+        const marker = m[1] ?? '';
+        const info = (m[2] ?? '').trim();
+        if (open) {
+            const sameChar = marker[0] === open.marker[0];
+            if (sameChar && marker.length >= open.marker.length && info === '')
+                open = null;
+            continue;
+        }
+        const lang = fenceLangOf(info);
+        open = { marker, lang };
+        if (fenceReserve(lang, marker) > fenceReserve(widest.lang, widest.marker)) {
+            widest = { marker, lang };
+        }
+    }
+    return widest;
+}
+//# sourceMappingURL=chunk.js.map

package/dist/src/messaging/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sourceRoot":"","sources":["../../../src/messaging/chunk.ts"],"names":[],"mappings":"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"}

package/dist/src/messaging/dedupe.js

@@ -0,0 +1,104 @@
+// ─── Delivery Deduplication ──────────────────────────
+// A time-bounded seen-set, shared by the channels that can be handed the same
+// delivery twice: a reconnecting updater replays, and a vendor retries when an
+// ack is slow. Processing one twice runs the agent twice.
+//
+// Promoted from the Slack socket client, which is where this was first got
+// right; the shape of the mistakes it avoids is recorded below.
+import { log } from '../core/logger.js';
+/**
+ * @param ttlMs   how long a delivery id stays remembered
+ * @param sweepAt size that triggers an expiry sweep
+ */
+export function createSeenSet(ttlMs, sweepAt = 5_000, maxTracked = MAX_TRACKED_DELIVERIES) {
+    // A Map iterates in insertion order and every entry is recorded with the
+    // current time, so the oldest entries are always at the front. That makes
+    // expiry a walk from the head that stops at the first live entry —
+    // proportional to what actually expired, not to the size of the set.
+    //
+    // Scanning the whole map instead was O(n) per insertion once it passed the
+    // sweep threshold, which is O(n²) over a burst: 60,000 ids took five
+    // seconds of synchronous work in a path that runs per inbound message.
+    const seenAt = new Map();
+    let warnedAtBudget = false;
+    // Head-ordered expiry assumes entries are stamped in non-decreasing order.
+    // Date.now() can go backwards — NTP correction, a manual clock change — and
+    // one older stamp behind a newer one parks an expired entry in front of the
+    // walk's stopping point, where it holds a slot until the newer one expires.
+    // Clamping to the last observation keeps the sequence monotonic.
+    let lastObserved = 0;
+    const monotonicNow = () => {
+        lastObserved = Math.max(lastObserved, Date.now());
+        return lastObserved;
+    };
+    const dropExpired = (now) => {
+        for (const [id, when] of seenAt) {
+            if (now - when < ttlMs)
+                break; // everything after this is younger
+            seenAt.delete(id);
+        }
+    };
+    return {
+        seen(key) {
+            const now = monotonicNow();
+            const at = seenAt.get(key);
+            if (at !== undefined && now - at < ttlMs)
+                return true;
+            // An expired key being seen again is re-recorded below. Delete it
+            // first so the Map re-inserts it at the BACK: insertion order is
+            // what makes expiry a walk from the head, and refreshing a key in
+            // place would leave a young entry sitting in front of older ones.
+            if (at !== undefined)
+                seenAt.delete(key);
+            // Expiry drops EXPIRED entries only. Evicting an unexpired id to
+            // hit a size target would let a delayed retry through — precisely
+            // the duplicate this exists to stop.
+            //
+            // It runs lazily rather than on a timer, because a timer here
+            // outlives the channel that created it; leaked timers were their
+            // own defect class in this codebase.
+            if (seenAt.size > sweepAt)
+                dropExpired(now);
+            // A TTL is not a bound on how many DISTINCT ids arrive inside it.
+            // Past the budget, stop admitting new keys: already-tracked ids
+            // keep their guarantee, and the set stops growing.
+            //
+            // The trade is explicit. Under a flood this degrades to "may
+            // reprocess a message" rather than "may exhaust memory", and only
+            // for ids arriving after the budget is reached.
+            if (seenAt.size >= maxTracked) {
+                // Reclaim before refusing: the budget is about live entries,
+                // and expired ones are not live. Refusing while dead entries
+                // hold slots would drop dedupe for traffic the set has room
+                // for — which is what a backwards clock step produced, since
+                // a stale stamp can sit ahead of the head-walk's stopping
+                // point and outlive its own window.
+                dropExpired(now);
+            }
+            if (seenAt.size >= maxTracked) {
+                if (!warnedAtBudget) {
+                    warnedAtBudget = true;
+                    log.warn(`[dedupe] tracking budget reached (${maxTracked}); new ids are no longer recorded`);
+                }
+                return false;
+            }
+            seenAt.set(key, now);
+            return false;
+        },
+        size: () => seenAt.size,
+    };
+}
+/**
+ * Distinct deliveries tracked at once.
+ *
+ * Reaching this is an anomaly, not routine: a single user's channel traffic is
+ * bounded by how fast a person types. Sized so a busy workspace never sees it
+ * while a flood cannot walk memory upward without limit.
+ */
+const MAX_TRACKED_DELIVERIES = 50_000;
+/**
+ * Ten minutes covers a vendor's retry horizon with room to spare, without
+ * holding ids long enough for the map to matter.
+ */
+export const DELIVERY_DEDUPE_TTL_MS = 10 * 60 * 1000;
+//# sourceMappingURL=dedupe.js.map

package/dist/src/messaging/dedupe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe.js","sourceRoot":"","sources":["../../../src/messaging/dedupe.ts"],"names":[],"mappings":"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"}