slack-term 1.27.0 → 1.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slack-term",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/snomiao/slack-term.git"
@@ -60,7 +60,7 @@
     "build": "bun build ts/cli.ts --target=node --outfile dist/cli.js --minify",
     "typecheck": "tsgo --noEmit",
     "typecheck:tsc": "tsc --noEmit",
-    "test": "bun test tests/ --timeout 90000 --isolate",
+    "test": "bun test tests/ --timeout 90000 --parallel=2",
     "test:watch": "bun test tests/ --timeout 90000 --isolate --watch",
     "test:parity": "bash tests/parity.sh",
     "record": "bun run tests/record.ts",

package/ts/ask.ts

@@ -22,11 +22,25 @@ export const ASK_MAX_REACTION_CHOICES = ASK_KEYCAPS.length;
 
 export type AskFound = { answer: string; how: string; who?: string };
 
-// The instruction line is the wire contract. `ask` keeps no local record of a
-// question, so `--waitFor` has to recover everything from the posted message —
-// and this line is what identifies it as an ask at all, and which answer paths
-// it promised to read. Change the wording and old in-flight questions become
-// unparseable, so treat these strings as a format version, not as copy.
+/** The marker that says "this message is an `ask`". A shortcode, so it is the
+ *  SAME token in every language — that is the whole point of it.
+ *
+ *  Identity used to live in the trailing Japanese instruction line, which made
+ *  the format untranslatable: rewording it in any language would have made every
+ *  in-flight question unparseable. The marker carries identity now, and the
+ *  instruction is free to be translated.
+ *
+ *  It is also seeded as a REACTION, which is what makes `has:question` list
+ *  every question the way `has:pushpin` lists every todo. `todo` gave this
+ *  emoji up (its needs-discussion flag moved to :thinking_face:) precisely so
+ *  the two would not collide in search. */
+export const ASK_MARKER = "question";
+export const ASK_MARKER_PREFIX = `:${ASK_MARKER}: `;
+
+// The instruction lines. These are ordinary copy now — translate them freely.
+// They are still matched verbatim when reading a message posted BEFORE the
+// marker existed, which is the only reason the exact old strings survive here:
+// deleting them would strand every question still in flight.
 const ASK_INSTRUCTION_REACTION_THREAD =
   "_下のリアクションを 1 つ押すと回答になります。当てはまるものがなければ、このメッセージの *スレッド* で返信してください (チャンネルへの通常投稿は回答として拾いません)。_";
 const ASK_INSTRUCTION_REACTION_HERE =
@@ -37,10 +51,55 @@ const ASK_INSTRUCTION_TEXT_HERE =
   "_このメッセージに返信してください。本文がそのまま回答になります。_";
 const ASK_OVERFLOW_NOTE = "_11 番目以降はリアクションがないので、返信で答えてください。_";
 
+// The invalid-ballot notice, shared by `ask` and `poll` and written INTO the
+// message rather than only onto the collector's terminal. The person who has to
+// fix it is the voter, and the voter is in Slack — a warning that only the
+// collector sees never reaches them.
+//
+// A line in the body, not a thread reply, and that is the whole point: it is
+// rewritten from the CURRENT state on every collection pass, so it cannot
+// duplicate across reruns and it disappears by itself the moment the extra
+// reaction is taken back. A reply, once posted, is a permanent record of a
+// situation that has since been fixed.
+const INVALID_PREFIX = "_:warning: 同時に複数選ばれているため回答として数えていません — どれか 1 つだけ残してください: ";
+const INVALID_SUFFIX = "_";
+
+/** The IDs named by a message's invalid-ballot line, or [] if it has none. */
+export function readInvalidNotice(text: string): string[] {
+  const lines = text.split("\n");
+  const line = lines[lines.length - 2];
+  if (line === undefined || !line.startsWith(INVALID_PREFIX) || !line.endsWith(INVALID_SUFFIX)) return [];
+  return [...line.matchAll(/<@([UW][A-Z0-9]+)>/g)].map((m) => m[1]!);
+}
+
+/** Put `invalid` into the body — inserting, replacing or REMOVING the notice so
+ *  the result depends only on the current state, never on how many times this
+ *  has run. Returns the text unchanged when nothing needs to move, which is the
+ *  caller's signal to skip the edit entirely.
+ *
+ *  The notice sits directly above the instruction line because that line has to
+ *  stay last: it is what identifies the message as an `ask`/`poll` at all. */
+export function applyInvalidNotice(text: string, invalid: string[]): string {
+  const lines = text.split("\n");
+  if (lines.length < 2) return text;
+  if (readInvalidNotice(text).length) lines.splice(lines.length - 2, 1);
+  if (invalid.length) {
+    lines.splice(lines.length - 1, 0, `${INVALID_PREFIX}${invalid.map((u) => `<@${u}>`).join(", ")}${INVALID_SUFFIX}`);
+  }
+  const out = lines.join("\n");
+  return out === text ? text : out;
+}
+
+/** True if this line is the notice — parsers skip it when walking up. */
+export function isInvalidNotice(line: string | undefined): boolean {
+  return line !== undefined && line.startsWith(INVALID_PREFIX) && line.endsWith(INVALID_SUFFIX);
+}
+
 /** Prefix `markResolved` stamps on a settled question. `--waitFor` keys "this
  *  was already answered while nobody was watching" off it, which is the whole
  *  reason a fire-and-forget ask can be collected later at all. */
-export const ASK_RESOLVED_PREFIX = ":white_check_mark: ";
+export const ASK_RESOLVED_MARKER = "white_check_mark";
+export const ASK_RESOLVED_PREFIX = `:${ASK_RESOLVED_MARKER}: `;
 
 /** One line, always: newlines inside a choice would break the line-based body. */
 function askFlatten(s: string): string {
@@ -51,7 +110,7 @@ function askFlatten(s: string): string {
  *  and an instruction naming the answer paths this command actually reads.
  *  `askParseMessage` is its inverse — keep the two in step. */
 export function askBuildText(question: string, body: string, reactable: string[], overflow: string[], threadOnly: boolean): string {
-  const lines: string[] = [`*${question}*`];
+  const lines: string[] = [`${ASK_MARKER_PREFIX}*${question}*`];
   if (body) lines.push("", body);
   if (reactable.length) {
     lines.push("");
@@ -98,6 +157,9 @@ export type AskParsed =
 export function askParseMessage(text: string): AskParsed {
   const lines = text.split("\n");
 
+  // Resolved is checked FIRST: a settled question carries the ✅ prefix where an
+  // open one carries the ❓ marker, and reading a resolved body as an open one
+  // would re-poll a question that already has its answer.
   if (text.startsWith(ASK_RESOLVED_PREFIX)) {
     const head = lines[0]!.slice(ASK_RESOLVED_PREFIX.length);
     const question = head.replace(/^\*/, "").replace(/\*$/, "");
@@ -114,6 +176,10 @@ export function askParseMessage(text: string): AskParsed {
   const last = lines[lines.length - 1] ?? "";
   let threadOnly: boolean;
   let hasChoices: boolean;
+  // Old-format fallback. A question posted before the marker existed is
+  // identified the only way it can be: by the instruction line it was built
+  // with. Never delete these cases — they are what keeps those questions
+  // collectable.
   switch (last) {
     case ASK_INSTRUCTION_REACTION_THREAD: threadOnly = true; hasChoices = true; break;
     case ASK_INSTRUCTION_REACTION_HERE: threadOnly = false; hasChoices = true; break;
@@ -125,6 +191,10 @@ export function askParseMessage(text: string): AskParsed {
   // The question is the leading bold run. Taking it up to the first line that
   // closes the `*` keeps a multi-line question intact instead of truncating it
   // to its first line.
+  // Strip the marker before reading the question, so the bold run starts at
+  // index 0 either way and a pre-marker body still parses.
+  const head = lines[0]!.startsWith(ASK_MARKER_PREFIX) ? lines[0]!.slice(ASK_MARKER_PREFIX.length) : lines[0]!;
+  lines[0] = head;
   if (!lines[0]!.startsWith("*")) return { kind: "other" };
   let end = 0;
   while (end < lines.length && !(lines[end]!.endsWith("*") && (end > 0 || lines[0]!.length > 1))) end++;
@@ -139,6 +209,7 @@ export function askParseMessage(text: string): AskParsed {
     // would let a body line that merely starts with a keycap ("1️⃣ これは本文です")
     // steal a choice slot and shift every number after it.
     let i = lines.length - 2; // the instruction itself is lines[length-1]
+    if (isInvalidNotice(lines[i])) i--;
     if (lines[i] !== "") return { kind: "other" };
     i--;
     if (lines[i] === ASK_OVERFLOW_NOTE) {