@raidiant/notifai 0.1.8 → 0.2.1

package/src/commands.test.ts

@@ -14,6 +14,7 @@ import { ApiCallError, NetworkError, type ApiClient } from './client.js'
 import {
   askCommand,
   accessStatusCommand,
+  buildQuestions,
   assessReadiness,
   capabilitiesCommand,
   configSetCommand,
@@ -379,7 +380,10 @@ describe('command contracts', () => {
         replyTimeout: 30,
       }),
     ).toBe(EXIT.ok)
-    expect(submitted?.draft.reply).toEqual({ expires_in_seconds: 3_600 })
+    expect(submitted?.draft.reply).toEqual({
+      expires_in_seconds: 3_600,
+      questions: [{ id: 'q1', text: 'Deploy?' }],
+    })
   })
 
   it('rejects --reply-timeout 0, the other spelling of nobody waiting', async () => {
@@ -630,7 +634,7 @@ describe('command contracts', () => {
       XDG_STATE_HOME: path.join(root, 'state'),
     }
     writeSessionState('pending-session', deps.env, {
-      pending: { question: 'Deploy?', request_id: receipt.request_id },
+      pending: [{ question: 'Deploy?', request_id: receipt.request_id }],
     })
     writeProjectSession(root, deps.env, 'pending-session', Date.now(), 'codex')
 
@@ -640,6 +644,36 @@ describe('command contracts', () => {
       'reply from iPhone: yes, after the migration',
     ])
   })
+
+  it('walks every delivered pending question in queue order', async () => {
+    const io = new CapturedIo()
+    const client = {
+      replies: async (requestId: string) =>
+        requestId === 'req_first'
+          ? replyResponse([reply])
+          : replyResponse([]),
+    } as unknown as ApiClient
+    const deps = makeDeps(io, client)
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-pending-multi-'))
+    deps.cwd = root
+    deps.env = {
+      XDG_CONFIG_HOME: path.join(root, 'config'),
+      XDG_STATE_HOME: path.join(root, 'state'),
+    }
+    writeSessionState('pending-multi', deps.env, {
+      pending: [
+        { question: 'Deploy?', request_id: 'req_first' },
+        { question: 'Which region?', request_id: 'req_second' },
+        { question: 'Not yet asked?' },
+      ],
+    })
+    writeProjectSession(root, deps.env, 'pending-multi', Date.now(), 'codex')
+
+    expect(await repliesCommand(deps, undefined, { pending: true })).toBe(EXIT.ok)
+    expect(io.outLines[0]).toBe('pending request req_first')
+    expect(io.outLines[1]).toContain('yes, after the migration')
+    expect(io.outLines.join('\n')).toContain('req_second')
+  })
 })
 
 describe('delivery evidence status', () => {
@@ -1147,7 +1181,7 @@ describe('init', () => {
       source: 'Raidiant-io/notifai',
       sourceType: 'github',
       sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-      ref: 'v0.1.8',
+      ref: 'v0.2.1',
     }
   }
 
@@ -1250,7 +1284,7 @@ describe('init', () => {
   })
 
   it('pins the skill installer to the tagged public release syntax', () => {
-    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.1.8')
+    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.2.1')
     expect(SKILLS_SOURCE).not.toContain('@v')
   })
 
@@ -1273,7 +1307,7 @@ describe('init', () => {
             source: 'Raidiant-io/notifai',
             sourceType: 'github',
             sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-            ref: 'v0.1.8',
+            ref: 'v0.2.1',
           },
         ],
       }),
@@ -2173,7 +2207,7 @@ describe('asking before the hooks have ever run', () => {
                   source: 'Raidiant-io/notifai',
                   sourceType: 'github',
                   sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-                  ref: 'v0.1.8',
+                  ref: 'v0.2.1',
                 },
               ]
             : [],
@@ -2233,7 +2267,7 @@ describe('asking before the hooks have ever run', () => {
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
-    expect(readSessionState('claude-parent-loop', env).pending?.question).toBe('Ship it?')
+    expect(readSessionState('claude-parent-loop', env).pending?.[0]?.question).toBe('Ship it?')
   })
 
   it('uses the OpenCode adapter marker instead of its config-directory variable', () => {
@@ -2271,7 +2305,7 @@ describe('asking before the hooks have ever run', () => {
     io.outLines = []
 
     expect(askCommand(deps, 'Ship it?', {})).toBe(EXIT.ok)
-    expect(readSessionState('cursor-live', env).pending?.question).toBe('Ship it?')
+    expect(readSessionState('cursor-live', env).pending?.[0]?.question).toBe('Ship it?')
   })
 
   it('fails doctor when another harness looks healthy but the active Claude Code session does not', async () => {
@@ -2295,6 +2329,39 @@ describe('asking before the hooks have ever run', () => {
     expect(io.outLines.join('\n')).toMatch(/FAIL\s+Question routing:.*active Claude Code/is)
   })
 
+  it('treats an unfired pointer as informational, with a prompt as the remedy', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-unfired-pointer-'))
+    const io = new CapturedIo()
+    const env = {
+      XDG_CONFIG_HOME: path.join(cwd, 'config'),
+      XDG_STATE_HOME: path.join(cwd, 'state'),
+      CLAUDE_CONFIG_DIR: path.join(cwd, 'claude-home'),
+      CODEX_HOME: path.join(cwd, 'codex-home'),
+      CLAUDECODE: '1',
+      CLAUDE_CODE_SESSION_ID: 'claude-current',
+    }
+    const deps = { ...makeDeps(io, {} as ApiClient), cwd, env, now: () => 42 }
+    expect(hooksInstallCommand(deps, { harness: 'claude-code', execPath, scriptPath })).toBe(
+      EXIT.ok,
+    )
+    // Hooks installed seconds ago, nothing has fired: the exact state a
+    // fresh-project agent `init` runs from. Neither pointer state may block
+    // the walk, and neither may prescribe a reinstall.
+    const readiness = await assessReadiness(deps)
+
+    const pointer = readiness.states.find((s) => s.id === 'hooks-active-session')
+    expect(pointer?.status).toBe('optional-gap')
+    expect(pointer?.detail).toMatch(/has not published a live pointer/)
+    expect(pointer?.remedy?.summary).toMatch(/send one Claude Code prompt/)
+    expect(pointer?.remedy?.by === 'user-here' ? pointer.remedy.command : '').toBe(
+      'notifai doctor',
+    )
+
+    const fired = readiness.states.find((s) => s.id === 'hooks-fired')
+    expect(fired?.status).toBe('optional-gap')
+    expect(fired?.remedy?.summary).not.toMatch(/hooks install/)
+  })
+
   it('shows resolved question-routing values with their winning config sources', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-doctor-routing-config-'))
     mkdirSync(path.join(cwd, '.notifai'), { recursive: true })
@@ -2486,7 +2553,97 @@ describe('a server behind this CLI', () => {
   })
 })
 
-/** First-reply-wins is the right default, silently is the wrong way. */
+describe('question sets', () => {
+  it('maps --reply-multi into the single question', async () => {
+    const io = new CapturedIo()
+    let submitted: SubmitNotificationRequestT | undefined
+    const client = {
+      submit: async (body: SubmitNotificationRequestT) => {
+        submitted = body
+        return receipt
+      },
+      replies: async () => replyResponse([reply]),
+    } as unknown as ApiClient
+
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        title: 'Question',
+        body: 'Which fronts?',
+        reply: true,
+        replyTimeout: 30,
+        replyChoice: ['CLI', 'Server', 'Apps'],
+        replyMulti: true,
+      }),
+    ).toBe(EXIT.ok)
+    expect(submitted?.draft.reply?.questions?.[0]).toMatchObject({
+      text: 'Which fronts?',
+      multi: true,
+    })
+    expect(submitted?.draft.reply?.questions?.[0]?.choices).toHaveLength(3)
+  })
+
+  it('rejects a question body too long for the answering surface', async () => {
+    const io = new CapturedIo()
+    let submitCalls = 0
+    const client = {
+      submit: async () => {
+        submitCalls += 1
+        return receipt
+      },
+    } as unknown as ApiClient
+
+    expect(
+      await sendCommand(makeDeps(io, client), {
+        title: 'Question',
+        body: 'x'.repeat(501),
+        reply: true,
+        replyTimeout: 30,
+      }),
+    ).toBe(EXIT.usage)
+    expect(submitCalls).toBe(0)
+    expect(io.errLines.join(' ')).toContain('--detail')
+  })
+
+  it('generates unique question ids when texts collide', () => {
+    const built = buildQuestions(
+      {
+        form: JSON.stringify({
+          questions: [{ text: 'Ready?' }, { text: 'Ready?' }],
+        }),
+      },
+      undefined,
+    )
+    expect(built).toMatchObject({ ok: true })
+    if (built.ok) {
+      expect(built.questions.map((question) => question.id)).toEqual(['ready', 'q2'])
+    }
+  })
+
+  it('rejects forms outside the documented shape', () => {
+    expect(buildQuestions({ form: 'not json' }, undefined)).toMatchObject({ ok: false })
+    expect(
+      buildQuestions({ form: JSON.stringify({ questions: [] }) }, undefined),
+    ).toMatchObject({ ok: false })
+    expect(
+      buildQuestions(
+        { form: JSON.stringify({ questions: Array.from({ length: 5 }, (_, i) => ({ text: `Q${i}?` })) }) },
+        undefined,
+      ),
+    ).toMatchObject({ ok: false, error: expect.stringContaining('1-4') })
+    expect(
+      buildQuestions(
+        { form: JSON.stringify({ questions: [{ text: 'Pick?', multi: true }] }) },
+        undefined,
+      ),
+    ).toMatchObject({ ok: false, error: expect.stringContaining('--choice') })
+    // --form replaces the flag surface; mixing them is a usage error.
+    expect(
+      buildQuestions({ form: JSON.stringify({ questions: [{ text: 'Q?' }] }) }, 'Also a question?'),
+    ).toMatchObject({ ok: false })
+  })
+})
+
+/** Latest-reply-wins, and never silently: a correction is named as one. */
 describe('a second device that disagrees', () => {
   function view(overrides: Partial<ReplyView>): ReplyView {
     return {
@@ -2496,27 +2653,28 @@ describe('a second device that disagrees', () => {
       device_id: 'dev',
       device_name: 'iPhone',
       text: 'Yes',
-      choice_id: null,
+      answers: [],
+      source: null,
       created_at: new Date().toISOString(),
       ...overrides,
     }
   }
 
-  it('says which answer counted and which was discarded', () => {
+  it('says the latest answer counted and which were superseded', () => {
     const said = contradictingAnswer([
       view({ seq: 1, device_name: 'iPhone', text: 'Yes' }),
       view({ seq: 2, device_name: 'FurankuMac', text: 'No' }),
     ])
-    expect(said).toContain('"Yes" from iPhone')
-    expect(said).toContain('FurankuMac')
-    expect(said).toMatch(/arrived first/)
+    expect(said).toContain('"No" from FurankuMac')
+    expect(said).toContain('iPhone')
+    expect(said).toMatch(/corrects an earlier one/)
   })
 
   it('is silent when the second answer agrees', () => {
     expect(
       contradictingAnswer([
-        view({ seq: 1, device_name: 'iPhone', text: 'Ship it', choice_id: 'ship' }),
-        view({ seq: 2, device_name: 'FurankuMac', text: 'Ship it', choice_id: 'ship' }),
+        view({ seq: 1, device_name: 'iPhone', text: 'Ship it', answers: [{ question_id: 'q1', choice_ids: ['ship'], text: null }] }),
+        view({ seq: 2, device_name: 'FurankuMac', text: 'Ship it', answers: [{ question_id: 'q1', choice_ids: ['ship'], text: null }] }),
       ]),
     ).toBeNull()
   })