@raidiant/notifai 0.2.0 → 0.3.0

package/src/commands.test.ts

@@ -17,7 +17,9 @@ import {
   buildQuestions,
   assessReadiness,
   capabilitiesCommand,
+  configExplainCommand,
   configSetCommand,
+  configShowCommand,
   contradictingAnswer,
   describeHookFailure,
   doctorCommand,
@@ -38,6 +40,8 @@ import {
 import { applyPlan, buildHookConfig } from './install-hooks.js'
 import { readSessionState, writeProjectSession, writeSessionState } from './hooks.js'
 import type { NativeSkill, NativeSkills, SkillScope } from './native-skills.js'
+import { CONFIG_KEYS } from './config.js'
+import type { Tone } from './ui/theme.js'
 
 class CapturedIo implements CommandIo {
   outLines: string[] = []
@@ -72,7 +76,7 @@ class InteractiveIo extends CapturedIo {
   intros: string[] = []
   outros: string[] = []
   spinnerEvents: string[] = []
-  checks: { ok: boolean; message: string }[] = []
+  checks: { ok: boolean; message: string; tone?: Tone }[] = []
 
   override async confirm(question: string) {
     this.prompts.push(question)
@@ -111,8 +115,8 @@ class InteractiveIo extends CapturedIo {
     }
   }
 
-  async check(ok: boolean, message: string) {
-    this.checks.push({ ok, message })
+  async check(ok: boolean, message: string, tone?: Tone) {
+    this.checks.push({ ok, message, ...(tone === undefined ? {} : { tone }) })
   }
 }
 
@@ -634,7 +638,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')
 
@@ -644,6 +648,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', () => {
@@ -889,6 +923,67 @@ describe('projectSlugFrom', () => {
   })
 })
 
+describe('config surfaces', () => {
+  function configDeps(io: CapturedIo): CommandDeps {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-config-surface-'))
+    return { ...makeDeps(io, {} as ApiClient), cwd, env: { XDG_CONFIG_HOME: path.join(cwd, 'xdg') } }
+  }
+
+  it('gives an agent the same flat key = value output it always had', () => {
+    // The whole point of gating the readable rendering on a human terminal.
+    // Anything parsing this today must keep parsing it tomorrow.
+    const io = new CapturedIo()
+    expect(configShowCommand(configDeps(io), {})).toBe(EXIT.ok)
+    expect(io.outLines).toHaveLength(CONFIG_KEYS.length)
+    expect(io.outLines[0]).toMatch(/^base_url = "/)
+    for (const line of io.outLines) expect(line).toMatch(/^[a-z_]+ = /)
+  })
+
+  it('explains each setting once a human is at the terminal', () => {
+    const io = new InteractiveIo()
+    expect(configShowCommand(configDeps(io), {})).toBe(EXIT.ok)
+    const text = io.outLines.join('\n')
+    expect(text).toContain('Questions & presence')
+    expect(text).toContain('Whether sitting at this keyboard holds a question back')
+  })
+
+  it('keeps --plain available to a human who wants the parseable form', () => {
+    const io = new InteractiveIo()
+    expect(configShowCommand(configDeps(io), { plain: true })).toBe(EXIT.ok)
+    expect(io.outLines).toHaveLength(CONFIG_KEYS.length)
+  })
+
+  it('explains one setting, and says so in JSON when asked', () => {
+    const io = new InteractiveIo()
+    expect(configExplainCommand(configDeps(io), 'require_idle', { json: true })).toBe(EXIT.ok)
+    const parsed = JSON.parse(io.outLines.join('\n')) as Record<string, unknown>
+    expect(parsed['key']).toBe('require_idle')
+    expect(parsed['accepts']).toBe('true or false')
+    expect(parsed['detail']).toContain('question waits while you are using this machine')
+  })
+
+  it('rejects an unknown setting and points at the nearest real one', () => {
+    const io = new CapturedIo()
+    expect(configExplainCommand(configDeps(io), 'require_idl')).toBe(EXIT.usage)
+    expect(io.errLines[0]).toBe('Unknown setting "require_idl".')
+  })
+
+  it('refuses an enum value the sender would later reject', async () => {
+    // `config set sound whatever` used to be written straight to disk: the
+    // typo only surfaced when a notification failed to carry the sound.
+    const io = new CapturedIo()
+    expect(await configSetCommand(configDeps(io), 'sound', 'whatever', { yes: true })).toBe(
+      EXIT.usage,
+    )
+    expect(io.errLines[0]).toContain('default, done, attention, alert, none')
+  })
+
+  it('still accepts a legal enum value', async () => {
+    const io = new CapturedIo()
+    expect(await configSetCommand(configDeps(io), 'sound', 'none', { yes: true })).toBe(EXIT.ok)
+  })
+})
+
 describe('interactive command UX', () => {
   it('styles login pairing progress for a human terminal', async () => {
     const io = new InteractiveIo()
@@ -1022,7 +1117,9 @@ describe('interactive command UX', () => {
     )
     expect(io.errLines).toEqual([
       'ask_grace_seconds must be between 0 and 540.',
-      '"1.5" is not an integer.',
+      // Names the key and its range: `"1.5" is not an integer` left the reader
+      // to work out which of the two settings they had just mistyped.
+      'ask_grace_seconds takes a whole number from 0s–540s, not "1.5".',
     ])
     expect(existsSync(configFile)).toBe(false)
   })
@@ -1051,6 +1148,18 @@ describe('interactive command UX', () => {
     expect(io.checks.some((check) => !check.ok && check.message.startsWith('This machine:'))).toBe(true)
     expect(io.checks.some((check) => check.ok && check.message.startsWith('Protocol version:'))).toBe(true)
     expect(io.outLines).toEqual([])
+
+    // Four tones, not two. A boolean has to round `optional-gap` and `unknown`
+    // to pass or fail, and rounding them to pass put a tick beside things the
+    // user had declined and beside things nothing had checked.
+    const tone = (prefix: string): Tone | undefined =>
+      io.checks.find((check) => check.message.startsWith(prefix))?.tone
+    expect(tone('This machine:')).toBe('bad')
+    expect(tone('Protocol version:')).toBe('ok')
+    // Never evaluated: the account cannot be checked without a credential.
+    expect(tone('Account:')).toBe('pending')
+    // Legitimately declined rather than broken.
+    expect(tone('Project identity:')).toBe('warn')
   })
 
   it('keeps doctor JSON as one machine-readable stdout document', async () => {
@@ -1151,7 +1260,7 @@ describe('init', () => {
       source: 'Raidiant-io/notifai',
       sourceType: 'github',
       sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-      ref: 'v0.2.0',
+      ref: 'v0.3.0',
     }
   }
 
@@ -1254,7 +1363,7 @@ describe('init', () => {
   })
 
   it('pins the skill installer to the tagged public release syntax', () => {
-    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.2.0')
+    expect(SKILLS_SOURCE).toBe('Raidiant-io/notifai#v0.3.0')
     expect(SKILLS_SOURCE).not.toContain('@v')
   })
 
@@ -1277,7 +1386,7 @@ describe('init', () => {
             source: 'Raidiant-io/notifai',
             sourceType: 'github',
             sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
-            ref: 'v0.2.0',
+            ref: 'v0.3.0',
           },
         ],
       }),
@@ -2177,7 +2286,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.2.0',
+                  ref: 'v0.3.0',
                 },
               ]
             : [],
@@ -2237,7 +2346,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', () => {
@@ -2275,7 +2384,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 () => {
@@ -2299,6 +2408,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 })