@raidiant/notifai 0.1.8 → 0.2.1

package/src/install-hooks.test.ts

@@ -44,28 +44,21 @@ function ours(): HookConfig {
 }
 
 describe('choice labels', () => {
-  it('splits a single value on commas for the one-liner case', () => {
-    expect(parseChoices('Staging,Production')).toEqual([
-      { id: 'staging', label: 'Staging' },
-      { id: 'production', label: 'Production' },
-    ])
-  })
-
-  it('keeps commas inside a label when the flag is repeated', () => {
-    // Observed live 2026-08-02: "Yes, it worked,No, something broke" passed as
-    // one value silently became four choices, and 2-6 validation let it
-    // through because four is in range. Repeating the flag is the escape.
+  it('treats a comma as an ordinary character, never a delimiter', () => {
+    // Observed live 2026-08-02 under the old comma-split grammar:
+    // "Yes, it worked,No, something broke" passed as one value silently
+    // became four choices. The delimiter form is gone; one flag, one answer.
     expect(parseChoices(['Yes, it worked', 'No, something broke'])).toEqual([
       { id: 'yes-it-worked', label: 'Yes, it worked' },
       { id: 'no-something-broke', label: 'No, something broke' },
     ])
-    expect(parseChoices('Yes, it worked,No, something broke')).toHaveLength(4)
+    expect(parseChoices(['Staging,Production', 'Neither'])).toEqual([
+      { id: 'staging-production', label: 'Staging,Production' },
+      { id: 'neither', label: 'Neither' },
+    ])
   })
 
   it('rejects a set that cannot become a valid closed question', () => {
-    // A pipe-separated string is one label, not two — the shape that reached
-    // the hook and failed there instead of at registration.
-    expect(parseChoices('Yes|No')).toBe('invalid')
     expect(parseChoices(['Only one'])).toBe('invalid')
     expect(parseChoices(['A', 'a'])).toBe('invalid')
     expect(parseChoices(['1', '2', '3', '4', '5', '6', '7'])).toBe('invalid')

package/src/main.ts

@@ -195,9 +195,10 @@ const send = program
   .option('--reply-window <seconds>', 'how long the server accepts a reply (default: 3600)', (v: string) => Number(v))
   .option(
     '--reply-choice <label>',
-    'with --reply, ask a closed question (2-6 answers); one value splits on commas, or repeat the flag',
+    'with --reply, ask a closed question; repeat the flag once per answer (2-6)',
     (v: string, all: string[]) => [...all, v], [],
   )
+  .option('--reply-multi', 'with --reply-choice, several answers may be selected')
   // Kept registered, and always a usage error with --reply, so the caller gets
   // a message pointing at `ask` instead of "unknown option".
   .option('--no-block', 'rejected with --reply; use `notifai ask` to ask and end the turn')
@@ -264,19 +265,55 @@ program
   })
 
 program
-  .command('ask <question>')
+  .command('ask [question]')
   .description('Register a question for the turn-end hook to route under your presence settings')
   .option(
     '--choice <label>',
-    'answers to offer instead of free text (2-6); one value splits on commas, or repeat the flag',
+    'answers to offer instead of free text; repeat the flag once per answer (2-6)',
     (v: string, all: string[]) => [...all, v], [],
   )
+  .option('--multi', 'with --choice, several answers may be selected')
+  .option('--detail <markdown>', 'long-form context shown only in the app, never on the banner')
+  .option('--detail-file <path>', 'read --detail from a file (use - for stdin)')
+  .option('--form <path>', 'ask several questions as one form; JSON file (use - for stdin)')
   .option('--session <id>', 'session id (default: the session working in this directory, else $NOTIFAI_SESSION)')
-  .action((question: string, opts: { choice?: string[]; session?: string }) => {
+  .action((question: string | undefined, opts: {
+    choice?: string[]
+    multi?: boolean
+    detail?: string
+    detailFile?: string
+    form?: string
+    session?: string
+  }) => {
+    let detail = opts.detail
+    if (typeof opts.detailFile === 'string') {
+      if (detail !== undefined) {
+        deps.io.err('Pass either --detail or --detail-file, not both.')
+        process.exit(2)
+      }
+      try {
+        detail = readFileSync(opts.detailFile === '-' ? 0 : opts.detailFile, 'utf8')
+      } catch (err) {
+        deps.io.err(`Could not read ${opts.detailFile}: ${String(err)}`)
+        process.exit(2)
+      }
+    }
+    let form: string | undefined
+    if (typeof opts.form === 'string') {
+      try {
+        form = readFileSync(opts.form === '-' ? 0 : opts.form, 'utf8')
+      } catch (err) {
+        deps.io.err(`Could not read ${opts.form}: ${String(err)}`)
+        process.exit(2)
+      }
+    }
     // commander's collector defaults to []; an empty list means "not asked".
     const flags: Parameters<typeof askCommand>[2] = {
       ...(opts.session !== undefined ? { session: opts.session } : {}),
       ...(opts.choice?.length ? { choice: opts.choice } : {}),
+      ...(opts.multi ? { multi: true } : {}),
+      ...(detail !== undefined ? { detail } : {}),
+      ...(form !== undefined ? { form } : {}),
     }
     process.exit(askCommand(deps, question, flags))
   })

package/src/send.ts

@@ -3,6 +3,7 @@ import {
   COLLAPSE_KEY_MAX_BYTES,
   INTERRUPTION_LEVELS,
   NOTIFICATION_SCHEMA_VERSION,
+  QUESTION_TEXT_MAX_LENGTH,
   type IosOptionsT,
   type LifecycleT,
   type MacosOptionsT,
@@ -10,6 +11,7 @@ import {
   NOTIFICATION_KINDS,
   PLATFORMS,
   type Platform,
+  type QuestionT,
   type SubmissionReceipt,
 } from '@raidiant/notifai-protocol'
 import type { CliConfig } from './config.js'
@@ -41,10 +43,17 @@ export interface SendFlags {
   /** How long the server accepts a reply after submission. */
   replyWindow?: number
   /**
-   * Answer labels; turns the reply into a closed question. One value splits on
-   * commas; repeating the flag passes each label through verbatim.
+   * Answer labels; turns the reply into a closed question. One flag occurrence
+   * per label, always — a label is a label, whatever characters it contains.
    */
-  replyChoice?: string | string[]
+  replyChoice?: string[]
+  /** The user may select several of the offered answers. */
+  replyMulti?: boolean
+  /**
+   * A full question set, overriding the single question the flags describe.
+   * Not a user-facing flag: `ask --form` and the hooks build it.
+   */
+  questions?: QuestionT[]
   /** Platform whose optional notification fields these flags configure. */
   platform?: string
   /**
@@ -149,6 +158,24 @@ export function buildDraft(config: CliConfig, flags: SendFlags): DraftBuild {
       error: CHOICE_USAGE,
     }
   }
+  if (flags.replyMulti && choices === null && flags.questions === undefined) {
+    return { ok: false, error: '--reply-multi needs answers to select between; add --reply-choice.' }
+  }
+  // The banner body doubles as the question text on a single-question send, so
+  // it inherits the question's readable-in-full bound; context beyond that
+  // belongs in --detail, which never rides the banner.
+  if (
+    flags.reply &&
+    flags.questions === undefined &&
+    flags.body.length > QUESTION_TEXT_MAX_LENGTH
+  ) {
+    return {
+      ok: false,
+      error:
+        `A question must be readable where it is answered: keep it within ${QUESTION_TEXT_MAX_LENGTH} ` +
+        'characters and put the longer context in --detail.',
+    }
+  }
 
   const draft: NotificationDraftT = {
     schema_version: NOTIFICATION_SCHEMA_VERSION,
@@ -174,7 +201,14 @@ export function buildDraft(config: CliConfig, flags: SendFlags): DraftBuild {
       ? {
           reply: {
             expires_in_seconds: flags.replyWindow ?? 3600,
-            ...(choices !== null ? { kind: 'choice' as const, choices } : {}),
+            questions: flags.questions ?? [
+              {
+                id: 'q1',
+                text: flags.body,
+                ...(choices !== null ? { choices } : {}),
+                ...(flags.replyMulti ? { multi: true } : {}),
+              },
+            ],
           },
         }
       : {}),
@@ -229,23 +263,19 @@ export function receiptExitCode(receipt: SubmissionReceipt): number {
 }
 
 /**
- * `"Staging,Production"` -> `[{id:'staging',label:'Staging'}, ...]`.
+ * One flag occurrence, one answer: `--choice Staging --choice Production` ->
+ * `[{id:'staging',label:'Staging'}, ...]`.
  *
- * A single occurrence splits on commas, which keeps the common one-liner
- * short. Repeating the flag is the escape hatch, and the only way to write a
- * label that itself contains a comma: passing `"Yes, ship it,No"` as one value
- * silently yields three choices, and nothing downstream can detect that the
- * agent meant two.
+ * Commas are ordinary characters. The old single-value comma split produced
+ * buttons the agent never intended ("Nothing, I'll review" became two answers)
+ * and nothing downstream could detect it, so the delimiter form is gone
+ * rather than guarded: a label is a label.
  */
 export function parseChoices(
-  value: string | string[] | undefined,
+  value: string[] | undefined,
 ): { id: string; label: string }[] | null | 'invalid' {
-  if (value === undefined) return null
-  const raw = Array.isArray(value) ? value : [value]
-  if (raw.length === 0) return null
-  const labels = (raw.length === 1 ? (raw[0] ?? '').split(',') : raw)
-    .map((part) => part.trim())
-    .filter((part) => part.length > 0)
+  if (value === undefined || value.length === 0) return null
+  const labels = value.map((part) => part.trim()).filter((part) => part.length > 0)
   if (labels.length < 2 || labels.length > 6) return 'invalid'
   const choices = labels.map((label) => ({ id: slugify(label), label }))
   if (choices.some((choice) => choice.id === '')) return 'invalid'
@@ -255,38 +285,10 @@ export function parseChoices(
 
 /** Message shared by every surface that accepts choice labels. */
 export const CHOICE_USAGE =
-  'Choices must be 2-6 non-empty labels, unique once slugified. One value splits on ' +
-  'commas ("Staging,Production"); repeat the flag when a label contains a comma.'
-
-/**
- * Catches the split that looked like it worked.
- *
- * `--choice "macOS parity,Long-form detail,Nothing, I'll review"` produced four
- * buttons rather than three, because the third label contained a comma. Nothing
- * downstream can detect it — the labels are all well-formed — and the CLI
- * cheerfully echoed the wrong list back, so the user saw buttons the agent
- * never intended.
- *
- * The tell is a comma followed by a space. A delimiter list is written
- * "Yes,No"; prose is written "Nothing, I'll review". That is a heuristic and it
- * will occasionally be wrong, which is exactly why this warns and names the
- * escape hatch rather than rejecting: the split may well have been intended.
- */
-export function ambiguousChoiceSplit(value: string | string[] | undefined): string | null {
-  if (value === undefined || Array.isArray(value)) return null
-  if (!/,\s/.test(value)) return null
-  const parts = value
-    .split(',')
-    .map((part) => part.trim())
-    .filter((part) => part.length > 0)
-  return (
-    `Heads up: "${value}" was split on commas into ${parts.length} answers ` +
-    `(${parts.join(' / ')}). If one of those labels was meant to contain a comma, ` +
-    'pass --choice once per answer instead.'
-  )
-}
+  'Offer 2-6 answers, one --choice flag per answer, unique once slugified — ' +
+  'e.g. --choice "Yes, ship it" --choice "Not yet".'
 
-function slugify(label: string): string {
+export function slugify(label: string): string {
   return label
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')