switchroom 0.18.25 → 0.18.26

package/telegram-plugin/tests/render/inline-pairs-guard.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect } from "vitest";
+import { guardAccidentalInlinePairs } from "../../render/inline-pairs-guard.js";
+
+// Strip defusing backslashes so we can assert the reader-visible text is
+// byte-identical to the original prose (the backslash is consumed by Telegram's
+// parser; copy-paste yields the clean glyph).
+function copyText(s: string): string {
+  return s.replace(/\\([~=|])/g, "$1");
+}
+
+describe("guardAccidentalInlinePairs — NO false positives on INTENDED formatting", () => {
+  // These are the hard constraint: the agent uses these DELIBERATELY. They must
+  // pass through byte-for-byte untouched.
+  it("leaves intended `~~strike~~` (word content) untouched", () => {
+    const s = "the ~~deprecated~~ flag is gone";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves intended single-tilde `~struck~` (word content) untouched", () => {
+    const s = "mark it ~struck~ for now";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves intended `==mark==` highlight untouched", () => {
+    const s = "please ==highlight this== part";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves two intended `==mark==` highlights untouched", () => {
+    const s = "==first== and also ==second== matter";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves intended `||spoiler||` untouched", () => {
+    const s = "the twist is ||he was dead|| all along";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves two intended `||spoiler||` spans untouched", () => {
+    const s = "reveal ||one|| then ||two|| slowly";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves intended `code` spans untouched (even with operators inside)", () => {
+    const s = "run `x==y` and `a||b` and `~10` in the shell";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves a single intended strike of a number `~~2024~~` untouched (below threshold)", () => {
+    const s = "the ~~2024~~ figure was revised";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves a lone comparison `x==y` untouched (cannot form a pair)", () => {
+    const s = "the check is x==y in the loop";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves a lone approximation `~10` untouched (cannot form a pair)", () => {
+    const s = "roughly ~10 items remain";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves space-flanked `a == b == c` untouched (cannot open a span)", () => {
+    const s = "assert a == b == c holds";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("is a strict no-op for text with none of the trigger chars", () => {
+    const s = "a perfectly ordinary sentence with no specials";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalInlinePairs — neutralises ACCIDENTAL pairs", () => {
+  it("breaks an accidental strikethrough from two approximation tildes", () => {
+    const s = "trims to ~10 units, down from ~20 last week";
+    const out = guardAccidentalInlinePairs(s);
+    // No unescaped digit-adjacent tilde survives to open a `~…~` span.
+    expect(out).not.toMatch(/(?<!\\)~(?=\$?\.?\d)/);
+    expect(out).toContain("\\~10");
+    expect(out).toContain("\\~20");
+    // Reader-visible prose unchanged once the defuser is stripped.
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("breaks an accidental strike from currency-approx tildes (`~$5M` / `~$9M`)", () => {
+    const s = "budget is ~$5M now, was ~$9M before";
+    const out = guardAccidentalInlinePairs(s);
+    expect(out).not.toMatch(/(?<!\\)~(?=\$?\.?\d)/);
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("breaks the inner tilde of a `~~10 ... ~~20` double-open accidental pair", () => {
+    const s = "about ~~10 to ~~20 percent";
+    const out = guardAccidentalInlinePairs(s);
+    expect(out).not.toMatch(/(?<!\\)~(?=\$?\.?\d)/);
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("breaks an accidental highlight from two `==` comparison operators", () => {
+    const s = "check x==y and then p==q in the guard";
+    const out = guardAccidentalInlinePairs(s);
+    expect(out).not.toMatch(/(?<=\w)==(?=\w)/);
+    expect(out).toContain("x\\=\\=y");
+    expect(out).toContain("p\\=\\=q");
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("breaks an accidental spoiler from two `||` logical-or operators", () => {
+    const s = "when a||b and c||d both hold";
+    const out = guardAccidentalInlinePairs(s);
+    expect(out).not.toMatch(/(?<=\w)\|\|(?=\w)/);
+    expect(out).toContain("a\\|\\|b");
+    expect(out).toContain("c\\|\\|d");
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("never escapes operators INSIDE a code span while fixing prose ones", () => {
+    const s = "prose x==y and p==q but code `m==n` stays";
+    const out = guardAccidentalInlinePairs(s);
+    // Prose operators neutralised…
+    expect(out).toContain("x\\=\\=y");
+    expect(out).toContain("p\\=\\=q");
+    // …code span verbatim.
+    expect(out).toContain("`m==n`");
+  });
+});
+
+describe("guardAccidentalInlinePairs — link / autolink awareness (finding 1)", () => {
+  it("leaves `==` inside a markdown link destination UNMODIFIED", () => {
+    const s = "see [a](https://x.io?p==1) and [b](https://y.io?q==2)";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves `~` (digit-adjacent) inside link destinations UNMODIFIED", () => {
+    const s = "see [a](https://x.io/~5x) and [b](https://y.io/~10y)";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves `==` inside a bare autolinked URL UNMODIFIED", () => {
+    const s = "open https://x.io/path?a==1&b==2 in a browser";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalInlinePairs — table awareness (finding 3)", () => {
+  it("leaves a real table's empty cells (`|a||b|`) UNMODIFIED", () => {
+    const s = ["| A | B | C |", "| --- | --- | --- |", "|a||b||c|"].join("\n");
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("STILL guards a genuine accidental `a||b` in prose (no delimiter row)", () => {
+    const out = guardAccidentalInlinePairs("eval a||b and c||d in code");
+    expect(out).toContain("a\\|\\|b");
+    expect(out).toContain("c\\|\\|d");
+  });
+});
+
+describe("guardAccidentalInlinePairs — idempotency", () => {
+  it("guarding already-guarded tilde text is a strict no-op", () => {
+    const once = guardAccidentalInlinePairs("trims to ~10 units, down from ~20 last week");
+    expect(guardAccidentalInlinePairs(once)).toBe(once);
+    expect(once).not.toContain("\\\\~"); // never a doubled backslash
+  });
+
+  it("guarding already-guarded `==`/`||` text is a strict no-op", () => {
+    const once = guardAccidentalInlinePairs("check x==y and p==q; also a||b and c||d");
+    expect(guardAccidentalInlinePairs(once)).toBe(once);
+  });
+});

package/telegram-plugin/tests/render/line-start-guard.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from "vitest";
+import { guardAccidentalBlockConstructs } from "../../render/line-start-guard.js";
+
+/** Strip the defusing backslashes so we can assert the reader-visible text is
+ *  byte-identical to the original prose (Telegram consumes the `\`). */
+function copyText(s: string): string {
+  return s.replace(/\\([>.)])/g, "$1");
+}
+
+describe("guardAccidentalBlockConstructs (#3252) — INTENDED formatting is never touched", () => {
+  // ── Headings: deferred entirely, must pass through untouched ──
+  it("leaves an intended `# ` heading untouched (deferred family)", () => {
+    const s = "# Project status\nAll green.";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `## `/`### ` sub-headings untouched", () => {
+    const s = "## Section\n### Subsection\nbody";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `#1` (no space, not a GFM heading) untouched — Telegram renders it literally", () => {
+    const s = "#1 priority is latency";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `# of items` untouched — deferred (indistinguishable from a heading)", () => {
+    const s = "# of items in the cart";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  // ── Intended blockquotes: `> ` with a space, never touched ──
+  it("leaves an intended `> quoted` blockquote untouched", () => {
+    const s = "> This is a real quote\n> spanning two lines";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `> 50% of users` untouched — spaced form is a valid/intended blockquote", () => {
+    const s = "> 50% of users prefer dark mode";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  // ── Bullet lists: deferred entirely, never touched ──
+  it("leaves `- ` bullets untouched (deferred family)", () => {
+    const s = "- first item\n- second item\n- 5 apples";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `* ` and `+ ` bullets untouched", () => {
+    const s = "* star bullet\n+ plus bullet";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `- 5 degrees` untouched — ambiguous with a bullet, deferred", () => {
+    const s = "- 5 degrees below freezing";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  // ── Ordered lists: small numbers are real lists, never touched ──
+  it("leaves a real `1.`/`2.`/`3.` numbered list untouched", () => {
+    const s = "1. First we plan\n2. Then we build\n3. Finally we ship";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves a 2–3 digit list marker (`42.`, `100.`) untouched — deferred", () => {
+    const s = "42. answer\n100. century";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves a decimal `3.14` untouched (no space after dot => not a list)", () => {
+    const s = "3.14 is pi and 2.71 is e";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  // ── Non-triggering prose ──
+  it("is a strict no-op for ordinary prose with no line-start triggers", () => {
+    const s = "just a normal sentence about the weather today";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalBlockConstructs (#3252) — accidental constructs ARE escaped", () => {
+  it("escapes a line-start `>2x` comparison (accidental blockquote)", () => {
+    const out = guardAccidentalBlockConstructs(">2x faster than before");
+    expect(out).toBe("\\>2x faster than before");
+    expect(copyText(out)).toBe(">2x faster than before");
+  });
+
+  it("escapes a line-start `>50%` comparison", () => {
+    const out = guardAccidentalBlockConstructs(">50% of the budget");
+    expect(out).toBe("\\>50% of the budget");
+  });
+
+  it("escapes a line-start `>=3` comparison", () => {
+    const out = guardAccidentalBlockConstructs(">=3 retries required");
+    expect(out).toBe("\\>=3 retries required");
+  });
+
+  it("escapes an accidental blockquote only on the offending line, mid-paragraph", () => {
+    const s = "Latency improved.\n>2x faster now\nShipping today.";
+    const out = guardAccidentalBlockConstructs(s);
+    expect(out).toBe("Latency improved.\n\\>2x faster now\nShipping today.");
+  });
+
+  it("escapes a 4+ digit year promoted to an ordered-list item (`2026. was`)", () => {
+    const out = guardAccidentalBlockConstructs("2026. was a great year for the team");
+    expect(out).toBe("2026\\. was a great year for the team");
+    expect(copyText(out)).toBe("2026. was a great year for the team");
+  });
+
+  it("escapes a `1999) ` year with the paren delimiter", () => {
+    const out = guardAccidentalBlockConstructs("1999) marked the dot-com peak");
+    expect(out).toBe("1999\\) marked the dot-com peak");
+  });
+
+  it("escapes the accidental ordered-list line only, inside a paragraph", () => {
+    const s = "Consider the timeline.\n2026. was pivotal\nThat is all.";
+    const out = guardAccidentalBlockConstructs(s);
+    expect(out).toBe("Consider the timeline.\n2026\\. was pivotal\nThat is all.");
+  });
+});
+
+describe("guardAccidentalBlockConstructs (#3252) — code / indent safety", () => {
+  it("never touches a `>` at the start of a FENCED code block line", () => {
+    const s = "```\n>2x in shell\n2026. code year\n```";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("never touches a `>` inside an inline code span", () => {
+    const s = "use `>2x` in the expression";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("does not treat a prose `>` that begins mid-line (after a code span) as a line start", () => {
+    // The `>5` is NOT at a real line start (an inline code span precedes it on
+    // the same line), so it must be left alone.
+    const s = "the value `x` >5 always";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves a 4-space indented (code) line untouched", () => {
+    const s = "    >2x indented code\n    2026. also code";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("still escapes a construct indented 1–3 spaces (valid block context)", () => {
+    const out = guardAccidentalBlockConstructs("  >2x slightly indented");
+    expect(out).toBe("  \\>2x slightly indented");
+  });
+});
+
+describe("guardAccidentalBlockConstructs (#3252) — idempotency & no-op signal", () => {
+  it("is idempotent: guarding already-guarded text is a strict no-op", () => {
+    const once = guardAccidentalBlockConstructs(">2x and\n2026. year");
+    expect(guardAccidentalBlockConstructs(once)).toBe(once);
+    expect(once).not.toContain("\\\\"); // never a doubled backslash
+  });
+
+  it("short-circuits to a strict no-op when there is no `>` and no 4+ digit marker", () => {
+    const s = "1. a\n2. b\n- c\n# d\n> e";
+    // All intended constructs; contains `>` so it runs, but produces no change.
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+});