@indigoai-us/hq-cli 5.116.0 → 5.117.0

package/dist/lib/bot/split.js

@@ -0,0 +1,241 @@
+/**
+ * A long reply, cut into posts HQ Cloud will actually accept.
+ *
+ * `POST /v1/notify/dm` refuses a body over DM_BODY_MAX characters with
+ * `400: Message body exceeds 4000 characters`. Nothing used to split, so a
+ * model answer over the limit was sent whole, refused, saved on the in-flight
+ * marker and re-sent identically on every poll — the answer was lost, the
+ * person was never told, and the bot asked the API to do the impossible about
+ * twice a second for as long as it ran.
+ *
+ * `splitBody` is the fix, and it is pure so it can be tested on its own:
+ *
+ * - a body at or under the limit comes back untouched, as one part
+ * - a longer body is cut on paragraph boundaries first, then on sentence
+ *   boundaries, and only hard-wrapped when a single sentence is still too long
+ * - a fenced code block is kept whole when it fits; when it cannot fit, the
+ *   fence is closed at the end of one part and reopened (with its language) at
+ *   the start of the next, so neither part renders as broken markdown
+ * - when there is more than one part, each is prefixed `(2/3)` on its own line
+ *   so the reader can see the order; the prefix is paid for out of the limit,
+ *   never added on top of it
+ *
+ * Every returned part is guaranteed to be at most `max` characters long.
+ */
+/** The largest body HQ Cloud accepts on a DM or channel post. */
+export const DM_BODY_MAX = 4000;
+const FENCE_RE = /^[ \t]*(`{3,}|~{3,})(.*)$/;
+function bare(line) {
+    return line.replace(/\r?\n$/, "");
+}
+/**
+ * The body as paragraphs and whole fenced code blocks, in order. Concatenating
+ * every `raw` reproduces the input exactly, so nothing is lost or reflowed
+ * before a cut is actually needed.
+ */
+function segmentize(body) {
+    const segments = [];
+    let buf = "";
+    let fence = null;
+    const flush = (fenceOpen) => {
+        if (buf)
+            segments.push({ raw: buf, fenceOpen });
+        buf = "";
+    };
+    for (const line of body.split(/(?<=\n)/)) {
+        const text = bare(line);
+        if (fence) {
+            buf += line;
+            const m = FENCE_RE.exec(text);
+            // A closing fence is the same character, at least as long, and bare.
+            if (m && m[1][0] === fence.marker[0] && m[1].length >= fence.marker.length && m[2].trim() === "") {
+                flush(fence.open);
+                fence = null;
+            }
+            continue;
+        }
+        const m = FENCE_RE.exec(text);
+        if (m) {
+            flush(null);
+            fence = { open: text.trimEnd(), marker: m[1] };
+            buf = line;
+            continue;
+        }
+        if (text.trim() === "") {
+            // A blank line closes the paragraph it follows.
+            if (buf)
+                buf += line;
+            else
+                buf = line;
+            flush(null);
+            continue;
+        }
+        buf += line;
+    }
+    flush(fence ? fence.open : null);
+    return segments;
+}
+/** Break points inside a paragraph: after sentence-ending punctuation, or at a line end. */
+function splitSentences(text) {
+    const parts = [];
+    const re = /(?:[.!?…]["'”’)\]]*|\n)[ \t]*\n?[ \t]*/g;
+    let start = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const end = m.index + m[0].length;
+        if (end <= start) {
+            re.lastIndex = start + 1;
+            continue;
+        }
+        parts.push(text.slice(start, end));
+        start = end;
+    }
+    if (start < text.length)
+        parts.push(text.slice(start));
+    return parts.length > 0 ? parts : [text];
+}
+/** Last resort: a run of text with no usable break, cut at whitespace when there is any. */
+function hardWrap(text, budget) {
+    const out = [];
+    let rest = text;
+    while (rest.length > budget) {
+        const window = rest.slice(0, budget);
+        const ws = Math.max(window.lastIndexOf(" "), window.lastIndexOf("\n"));
+        const cut = ws > 0 && ws >= Math.floor(budget * 0.6) ? ws : budget;
+        const piece = rest.slice(0, cut).trim();
+        if (piece)
+            out.push(piece);
+        rest = rest.slice(cut).replace(/^[ \t\n]+/, "");
+    }
+    const tail = rest.trim();
+    if (tail)
+        out.push(tail);
+    return out;
+}
+/** A code block too long for one part: closed and reopened around every cut. */
+function splitFenced(segment, budget) {
+    const open = segment.fenceOpen ?? "```";
+    const marker = FENCE_RE.exec(open)?.[1] ?? "```";
+    const overhead = open.length + marker.length + 2; // the two fence lines and their newlines
+    const inner = budget - overhead;
+    if (inner < 1)
+        return splitPlain(segment.raw, budget);
+    const lines = segment.raw.split(/(?<=\n)/).slice(1);
+    const last = lines[lines.length - 1];
+    if (last !== undefined) {
+        const m = FENCE_RE.exec(bare(last));
+        if (m && m[1][0] === marker[0] && m[2].trim() === "")
+            lines.pop();
+    }
+    const pieces = [];
+    let buf = "";
+    const emit = () => {
+        const code = buf.replace(/\n+$/, "");
+        buf = "";
+        if (code.trim() === "")
+            return;
+        pieces.push(`${open}\n${code}\n${marker}`);
+    };
+    for (const line of lines) {
+        if ((buf + line).replace(/\n+$/, "").length <= inner) {
+            buf += line;
+            continue;
+        }
+        emit();
+        const one = bare(line);
+        if (one.length <= inner) {
+            buf = line;
+            continue;
+        }
+        for (const wrapped of hardWrap(one, inner)) {
+            buf = wrapped;
+            emit();
+        }
+    }
+    emit();
+    return pieces.length > 0 ? pieces : splitPlain(segment.raw, budget);
+}
+/** A paragraph too long for one part: sentences first, hard wrap only if one sentence is still too long. */
+function splitPlain(text, budget) {
+    const out = [];
+    let buf = "";
+    const flush = () => {
+        const t = buf.trim();
+        buf = "";
+        if (t)
+            out.push(t);
+    };
+    for (const sentence of splitSentences(text)) {
+        if ((buf + sentence).trim().length <= budget) {
+            buf += sentence;
+            continue;
+        }
+        flush();
+        if (sentence.trim().length <= budget) {
+            buf = sentence;
+            continue;
+        }
+        for (const wrapped of hardWrap(sentence.trim(), budget))
+            out.push(wrapped);
+    }
+    flush();
+    return out.length > 0 ? out : hardWrap(text.trim(), budget);
+}
+function pack(body, budget) {
+    const out = [];
+    let acc = "";
+    const flush = () => {
+        const t = acc.trim();
+        acc = "";
+        if (t)
+            out.push(t);
+    };
+    for (const segment of segmentize(body)) {
+        if ((acc + segment.raw).trim().length <= budget) {
+            acc += segment.raw;
+            continue;
+        }
+        flush();
+        if (segment.raw.trim().length <= budget) {
+            acc = segment.raw;
+            continue;
+        }
+        for (const piece of segment.fenceOpen ? splitFenced(segment, budget) : splitPlain(segment.raw, budget)) {
+            out.push(piece);
+        }
+    }
+    flush();
+    return out;
+}
+/** `(2/3)` and its newline, at the widest the count can make it. */
+function prefixWidth(count) {
+    return `(${count}/${count})\n`.length;
+}
+function label(parts) {
+    if (parts.length < 2)
+        return parts;
+    return parts.map((part, i) => `(${i + 1}/${parts.length})\n${part}`);
+}
+/**
+ * One outbound body as the ordered parts to post, each at most `max`
+ * characters. A body that already fits comes back unchanged.
+ */
+export function splitBody(body, max = DM_BODY_MAX) {
+    const limit = Math.max(1, Math.floor(max));
+    if (body.length <= limit)
+        return [body];
+    let reserve = prefixWidth(2);
+    let parts = [];
+    for (let round = 0; round < 6; round += 1) {
+        parts = pack(body, Math.max(1, limit - reserve));
+        const needed = parts.length > 1 ? prefixWidth(parts.length) : 0;
+        if (needed <= reserve)
+            break;
+        reserve = needed;
+    }
+    if (parts.length === 0)
+        parts = [body.trim() || body];
+    // Belt and braces: whatever the shape of the input, no part may exceed the limit.
+    return label(parts).flatMap((part) => (part.length <= limit ? [part] : hardWrap(part, limit)));
+}
+//# sourceMappingURL=split.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.116.0",
+  "version": "5.117.0",
   "description": "HQ by Indigo management CLI \u2014 modules and cloud sync",
   "main": "dist/index.js",
   "bin": {