@raidiant/notifai 0.5.0 → 1.0.0

package/src/interactive.ts

@@ -36,6 +36,7 @@ import {
   deviceInventory,
   doctorCommand,
   hooksInstallCommand,
+  hooksUninstallCommand,
   initCommand,
   loginCommand,
   logoutCommand,
@@ -43,6 +44,11 @@ import {
   type CommandDeps,
 } from './commands.js'
 import { CONFIG_KEYS, loadConfig, type CliConfig, type ConfigKey } from './config.js'
+import {
+  detectedHarnesses,
+  findInstallations,
+  type Installation,
+} from './install-hooks.js'
 import {
   CONFIG_GROUPS,
   acceptedValues,
@@ -53,15 +59,112 @@ import {
   formatValue,
   type ConfigGroup,
 } from './config-schema.js'
-import { firstBlocker, type Readiness, type ReadinessState } from './readiness.js'
+import {
+  firstBlocker,
+  refreshAfterMenuAction,
+  type Readiness,
+  type ReadinessRefresh,
+  type ReadinessState,
+} from './readiness.js'
 import { printBanner, tagline } from './ui/banner.js'
 import { card, glyph, mark, style, type Tone } from './ui/theme.js'
 
 /** Clack returns a symbol when the user pressed Ctrl-C or Escape. */
-function cancelled(value: unknown): boolean {
+function cancelled(value: unknown): value is symbol {
   return clack.isCancel(value)
 }
 
+export type HookScope = 'project' | 'machine'
+
+export type RoutingAction = 'install' | 'uninstall' | 'settings' | 'back'
+
+export interface MenuOption<Value extends string> {
+  value: Value
+  label: string
+  hint?: string
+}
+
+/**
+ * Which hook actions this directory and setup can actually perform.
+ *
+ * Install is offered only when a harness is detectable here. Uninstall is
+ * offered only for a scope that already has Notifai hooks, and the label names
+ * that scope so a machine-wide install is never stripped from a random folder
+ * under a generic "uninstall".
+ */
+export function routingHookActions(input: {
+  canInstall: boolean
+  projectInstallations: readonly { harness: string }[]
+  machineInstallations: readonly { harness: string }[]
+  hooksReady: boolean
+}): MenuOption<RoutingAction>[] {
+  const options: MenuOption<RoutingAction>[] = []
+  const hasProject = input.projectInstallations.length > 0
+  const hasMachine = input.machineInstallations.length > 0
+  const hasAny = hasProject || hasMachine
+
+  if (input.canInstall) {
+    options.push({
+      value: 'install',
+      label: input.hooksReady || hasAny ? 'Re-install hooks' : 'Install hooks',
+      hint: 'this project or this machine',
+    })
+  }
+
+  if (hasProject && hasMachine) {
+    options.push({
+      value: 'uninstall',
+      label: 'Uninstall hooks',
+      hint: 'this project or this machine',
+    })
+  } else if (hasProject) {
+    options.push({
+      value: 'uninstall',
+      label: 'Uninstall hooks for this project',
+      hint: harnessHint(input.projectInstallations),
+    })
+  } else if (hasMachine) {
+    options.push({
+      value: 'uninstall',
+      label: 'Uninstall hooks on this machine',
+      hint: harnessHint(input.machineInstallations),
+    })
+  }
+
+  options.push(
+    { value: 'settings', label: 'Change presence settings', hint: 'when a question may leave this terminal' },
+    { value: 'back', label: '← Back' },
+  )
+  return options
+}
+
+/** Scope choices that would actually remove something. Project first. */
+export function uninstallScopeOptions(
+  projectInstallations: readonly { harness: string }[],
+  machineInstallations: readonly { harness: string }[],
+): MenuOption<HookScope>[] {
+  const options: MenuOption<HookScope>[] = []
+  if (projectInstallations.length > 0) {
+    options.push({
+      value: 'project',
+      label: 'This project',
+      hint: 'remove hooks from this directory',
+    })
+  }
+  if (machineInstallations.length > 0) {
+    options.push({
+      value: 'machine',
+      label: 'This machine',
+      hint: 'remove hooks for every project here',
+    })
+  }
+  return options
+}
+
+function harnessHint(installations: readonly { harness: string }[]): string {
+  return [...new Set(installations.map((installation) => installation.harness))].join(', ')
+}
+
 type Screen =
   | 'test'
   | 'devices'
@@ -87,6 +190,7 @@ export async function interactiveCommand(deps: CommandDeps, version: string): Pr
       message: 'What would you like to do?',
       options: menuFor(readiness),
     })
+    // Root is the only place Escape/Ctrl-C quits. Every nested prompt returns.
     if (cancelled(choice)) return farewell()
 
     switch (choice) {
@@ -94,28 +198,38 @@ export async function interactiveCommand(deps: CommandDeps, version: string): Pr
         return farewell()
       case 'setup':
         await initCommand(deps, {})
-        readiness = await assess(deps)
+        readiness = await refresh(deps, readiness, refreshAfterMenuAction('setup', true))
         break
-      case 'account':
-        if (await accountScreen(deps, readiness)) readiness = await assess(deps)
+      case 'account': {
+        const changed = await accountScreen(deps, readiness)
+        readiness = await refresh(deps, readiness, refreshAfterMenuAction('account', changed))
         break
+      }
       case 'test':
         await testNotificationScreen(deps)
-        readiness = await assess(deps)
         break
       case 'devices':
         await devicesScreen(deps)
         break
-      case 'settings':
-        await settingsScreen(deps)
-        readiness = await assess(deps)
+      case 'settings': {
+        const result = await settingsScreen(deps)
+        readiness = await refresh(
+          deps,
+          readiness,
+          refreshAfterMenuAction('settings', result !== 'unchanged', { remote: result === 'remote' }),
+        )
         break
-      case 'routing':
-        if (await routingScreen(deps, readiness)) readiness = await assess(deps)
+      }
+      case 'routing': {
+        const changed = await routingScreen(deps, readiness)
+        readiness = await refresh(deps, readiness, refreshAfterMenuAction('routing', changed))
         break
+      }
       case 'doctor':
-        await doctorCommand(deps, {})
+        // One assessment serves the report and the redraw. Doctor does not
+        // change setup, so running the graph again would only wait.
         readiness = await assess(deps)
+        await doctorCommand(deps, {}, { readiness })
         break
     }
   }
@@ -126,16 +240,27 @@ function farewell(): number {
   return EXIT.ok
 }
 
-async function assess(deps: CommandDeps): Promise<Readiness> {
+async function assess(
+  deps: CommandDeps,
+  options: { previous?: Readiness; refresh?: readonly ReadinessRefresh[] } = {},
+): Promise<Readiness> {
   const spinner = clack.spinner()
   spinner.start('Checking your setup')
   try {
-    return await assessReadiness(deps)
+    return await assessReadiness(deps, options)
   } finally {
     spinner.stop(style.dim('Setup checked'))
   }
 }
 
+async function refresh(
+  deps: CommandDeps,
+  previous: Readiness,
+  next: readonly ReadinessRefresh[] | null,
+): Promise<Readiness> {
+  return next === null ? previous : assess(deps, { previous, refresh: next })
+}
+
 // ---------------------------------------------------------------------------
 // Status
 // ---------------------------------------------------------------------------
@@ -294,23 +419,21 @@ async function testNotificationScreen(deps: CommandDeps): Promise<void> {
   })
   if (cancelled(body)) return
 
-  const sound = await clack.select<string>({
-    message: 'Sound',
+  const kind = await clack.select<string>({
+    message: 'Kind',
     options: [
-      { value: 'default', label: 'Default', hint: 'the standard tone' },
-      { value: 'done', label: 'Done', hint: 'the completion chime' },
-      { value: 'attention', label: 'Attention' },
-      { value: 'none', label: 'Silent' },
+      { value: 'update', label: 'Update', hint: 'something happened' },
+      { value: 'done', label: 'Done', hint: 'work finished' },
     ],
-    initialValue: 'default',
+    initialValue: 'done',
   })
-  if (cancelled(sound)) return
+  if (cancelled(kind)) return
 
   clack.log.step('Sending, then waiting for your devices to confirm…')
   const code = await sendCommand(deps, {
     title: String(title),
     body: String(body),
-    sound: String(sound),
+    kind: String(kind),
     ...(project !== null ? { project } : {}),
   })
   if (code === EXIT.ok) clack.log.success('Delivered. Check the device it landed on.')
@@ -359,7 +482,8 @@ async function devicesScreen(deps: CommandDeps): Promise<void> {
 // Settings
 // ---------------------------------------------------------------------------
 
-async function settingsScreen(deps: CommandDeps): Promise<void> {
+async function settingsScreen(deps: CommandDeps): Promise<'unchanged' | 'local' | 'remote'> {
+  let result: 'unchanged' | 'local' | 'remote' = 'unchanged'
   for (;;) {
     const config = loadConfig({ cwd: deps.cwd, env: deps.env })
     const group = await clack.select<ConfigGroup | 'back'>({
@@ -373,8 +497,10 @@ async function settingsScreen(deps: CommandDeps): Promise<void> {
         { value: 'back' as const, label: '← Back' },
       ],
     })
-    if (cancelled(group) || group === 'back') return
-    await settingsGroupScreen(deps, group as ConfigGroup)
+    if (cancelled(group) || group === 'back') return result
+    const next = await settingsGroupScreen(deps, group as ConfigGroup)
+    if (next === 'remote') result = 'remote'
+    else if (next === 'local' && result === 'unchanged') result = 'local'
   }
 }
 
@@ -385,7 +511,11 @@ function changedCount(config: CliConfig, group: ConfigGroup): string {
   return changed === 0 ? style.dim('all default') : style.dim(`${changed} changed`)
 }
 
-async function settingsGroupScreen(deps: CommandDeps, group: ConfigGroup): Promise<void> {
+async function settingsGroupScreen(
+  deps: CommandDeps,
+  group: ConfigGroup,
+): Promise<'unchanged' | 'local' | 'remote'> {
+  let result: 'unchanged' | 'local' | 'remote' = 'unchanged'
   for (;;) {
     const config = loadConfig({ cwd: deps.cwd, env: deps.env })
     const info = CONFIG_GROUPS.find((entry) => entry.id === group)!
@@ -407,8 +537,10 @@ async function settingsGroupScreen(deps: CommandDeps, group: ConfigGroup): Promi
         { value: 'back' as const, label: '← Back' },
       ],
     })
-    if (cancelled(key) || key === 'back') return
-    await settingDetailScreen(deps, key as ConfigKey)
+    if (cancelled(key) || key === 'back') return result
+    const next = await settingDetailScreen(deps, key as ConfigKey)
+    if (next === 'remote') result = 'remote'
+    else if (next === 'local' && result === 'unchanged') result = 'local'
   }
 }
 
@@ -419,7 +551,10 @@ async function settingsGroupScreen(deps: CommandDeps, group: ConfigGroup): Promi
  * so that arriving here means the reader has already said which key they care
  * about.
  */
-async function settingDetailScreen(deps: CommandDeps, key: ConfigKey): Promise<void> {
+async function settingDetailScreen(
+  deps: CommandDeps,
+  key: ConfigKey,
+): Promise<'unchanged' | 'local' | 'remote'> {
   const config = loadConfig({ cwd: deps.cwd, env: deps.env })
   const info = configInfo(key)
   const resolved = config[key]
@@ -444,20 +579,22 @@ async function settingDetailScreen(deps: CommandDeps, key: ConfigKey): Promise<v
     ],
     initialValue: 'back',
   })
-  if (cancelled(action) || action === 'back') return
+  if (cancelled(action) || action === 'back') return 'unchanged'
 
   const value = await promptForValue(deps, key)
-  if (value === null) return
+  if (value === null) return 'unchanged'
 
   const layer = await chooseLayer()
-  if (layer === null) return
+  if (layer === null) return 'unchanged'
 
   const code = await configSetCommand(deps, key, value, {
     yes: true,
     ...(layer === 'project' ? { project: true } : {}),
     ...(layer === 'local' ? { local: true } : {}),
   })
-  if (code === EXIT.ok) clack.log.success(`${info.label} is now ${formatValueRaw(key, value)}`)
+  if (code !== EXIT.ok) return 'unchanged'
+  clack.log.success(`${info.label} is now ${formatValueRaw(key, value)}`)
+  return 'local'
 }
 
 function formatValueRaw(key: ConfigKey, raw: string): string {
@@ -589,6 +726,9 @@ function wiringSummary(hooks: ReadinessState | undefined): string {
 async function routingScreen(deps: CommandDeps, readiness: Readiness): Promise<boolean> {
   const hooks = stateById(readiness, 'hooks')
   const config = loadConfig({ cwd: deps.cwd, env: deps.env })
+  const installations = findInstallations(deps.cwd, deps.env, deps.hookAdapterHome)
+  const projectInstallations = installations.filter((installation) => !installation.global)
+  const machineInstallations = installations.filter((installation) => installation.global)
 
   const row = (label: string, value: string): string => `${style.dim(label.padEnd(16))}${value}`
   clack.note(
@@ -604,17 +744,14 @@ async function routingScreen(deps: CommandDeps, readiness: Readiness): Promise<b
     'Question routing',
   )
 
-  const action = await clack.select<'install' | 'settings' | 'back'>({
+  const action = await clack.select<RoutingAction>({
     message: 'Question routing',
-    options: [
-      {
-        value: 'install',
-        label: hooks?.status === 'ready' ? 'Re-install hooks for this harness' : 'Wire up my harness',
-        hint: 'Claude Code, Codex, Cursor, OpenCode',
-      },
-      { value: 'settings', label: 'Change presence settings', hint: 'when a question may leave this terminal' },
-      { value: 'back', label: '← Back' },
-    ],
+    options: routingHookActions({
+      canInstall: detectedHarnesses(deps.cwd, deps.env).length > 0,
+      projectInstallations,
+      machineInstallations,
+      hooksReady: hooks?.status === 'ready',
+    }),
   })
   if (cancelled(action) || action === 'back') return false
 
@@ -623,16 +760,51 @@ async function routingScreen(deps: CommandDeps, readiness: Readiness): Promise<b
     return true
   }
 
-  const scope = await clack.select<'project' | 'global'>({
-    message: 'Install for',
+  if (action === 'install') return await installHooksInteractively(deps)
+  return await uninstallHooksInteractively(deps, projectInstallations, machineInstallations)
+}
+
+async function installHooksInteractively(deps: CommandDeps): Promise<boolean> {
+  const scope = await clack.select<HookScope>({
+    message: 'Install hooks for',
     options: [
-      { value: 'project', label: 'This project only' },
-      { value: 'global', label: 'Every project on this machine' },
+      { value: 'project', label: 'This project', hint: 'hooks only in this directory' },
+      { value: 'machine', label: 'This machine', hint: 'hooks for every project here' },
     ],
     initialValue: 'project',
   })
   if (cancelled(scope)) return false
-  hooksInstallCommand(deps, scope === 'global' ? { global: true } : {})
+  hooksInstallCommand(deps, scope === 'machine' ? { global: true } : {})
+  return true
+}
+
+async function uninstallHooksInteractively(
+  deps: CommandDeps,
+  projectInstallations: Installation[],
+  machineInstallations: Installation[],
+): Promise<boolean> {
+  const scopes = uninstallScopeOptions(projectInstallations, machineInstallations)
+  if (scopes.length === 0) return false
+
+  let scope: HookScope
+  if (scopes.length === 1) {
+    scope = scopes[0]!.value
+  } else {
+    const picked = await clack.select<HookScope | 'back'>({
+      message: 'Uninstall hooks from',
+      options: [...scopes, { value: 'back', label: '← Back' }],
+    })
+    if (cancelled(picked) || picked === 'back') return false
+    scope = picked
+  }
+
+  const targets = scope === 'machine' ? machineInstallations : projectInstallations
+  for (const installation of targets) {
+    hooksUninstallCommand(deps, {
+      harness: installation.harness,
+      global: installation.global,
+    })
+  }
   return true
 }
 

package/src/main.ts

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 import { readFileSync } from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { Command } from 'commander'
 import {
   askCommand,
@@ -30,6 +28,7 @@ import {
   type CommandDeps,
 } from './commands.js'
 import { defaultCredentialStore } from './credentials.js'
+import { packageVersion } from './release.js'
 import { HARNESSES } from './install-hooks.js'
 import type { Platform } from '@raidiant/notifai-protocol'
 import { nativeSkills, type SkillScope } from './native-skills.js'
@@ -64,18 +63,13 @@ const deps: CommandDeps = {
  * does not hold — `package.json` moved and `notifai --version` kept reporting
  * the old number, which is exactly the string someone pastes into a bug report
  * to say what they are running.
+ *
+ * `unknown` is the display form of "this build cannot tell"; the skill pin
+ * derived from the same source refuses instead, because a wrong ref installs
+ * the wrong thing while a wrong version string only misinforms.
  */
 function version(): string {
-  try {
-    const manifest = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json')
-    const parsed: unknown = JSON.parse(readFileSync(manifest, 'utf8'))
-    if (typeof parsed === 'object' && parsed !== null && typeof (parsed as { version?: unknown }).version === 'string') {
-      return (parsed as { version: string }).version
-    }
-  } catch {
-    // Fall through: an unreadable manifest must not stop the CLI running.
-  }
-  return 'unknown'
+  return packageVersion() ?? 'unknown'
 }
 
 /**
@@ -205,7 +199,7 @@ program
   .summary('Sign in and pair this machine')
   .description('Pair this machine with your Notifai account via browser approval')
   .option('--name <name>', 'machine name shown in the dashboard (default: hostname)')
-  .option('--base-url <url>', 'Notifai server URL')
+  .option('--base-url <url>', 'developer override for the service origin (also NOTIFAI_BASE_URL)')
   .option('--no-open', 'do not open the approval page in a browser')
   .action(async (opts: { name?: string; baseUrl?: string; open?: boolean }) => {
     process.exit(await loginCommand(deps, opts))
@@ -281,8 +275,6 @@ const send = program
   .option('--session <id>', 'session identity (env: NOTIFAI_SESSION); presentation varies by surface')
   .option('--event <event>', 'agent event name, e.g. tests_passed')
   .optionsGroup(SEND_GROUP.presentation)
-  .option('--sound <sound>', 'default | done | attention | alert | none')
-  .option('--level <level>', 'interruption level: passive | active | time_sensitive')
   .option('--collapse-key <key>', 'replace earlier notifications with the same key')
   .option('--thread-id <id>', 'group related notifications')
   .option('--ttl <seconds>', 'delivery window in seconds', (v: string) => Number(v))
@@ -301,11 +293,13 @@ const send = program
   // a message pointing at `ask` instead of "unknown option".
   .option('--no-block', 'rejected with --reply; use `notifai ask` to ask and end the turn')
   .optionsGroup(SEND_GROUP.advanced)
+  .option('--sound <sound>', 'override kind profile / saved config: default | done | attention | alert | none')
+  .option('--level <level>', 'override kind profile / saved config: passive | active | time_sensitive')
   .option('--wait <seconds>', 'how long to wait for provider outcomes', (v: string) => Number(v))
   .option('--no-wait', 'return immediately after acceptance')
   .option('--data <key=value>', 'custom data (repeatable)', (v: string, all: string[]) => [...all, v], [])
   .option('--idempotency-key <key>', 'safe-retry key (default: random)')
-  .option('--base-url <url>', 'Notifai server URL')
+  .option('--base-url <url>', 'developer override for the service origin (also NOTIFAI_BASE_URL)')
   .option('--json', 'print the full submission receipt as JSON')
   .action(async (opts: Record<string, unknown>) => {
     // commander maps --no-wait onto the same "wait" flag; disentangle.
@@ -342,7 +336,7 @@ const send = program
 
 send.addHelpText(
   'after',
-  `\nKind profiles (used unless --sound, --level, or saved user config overrides them):\n  update    sound none       level passive\n  done      sound done       level passive\n  question  sound attention  level active (--reply)\n`,
+  `\nKind profiles apply automatically. Pass --sound or --level only to override them or saved user config:\n  update    sound none       level passive\n  done      sound done       level passive\n  question  sound attention  level active (--reply)\n`,
 )
 
 program
@@ -461,7 +455,7 @@ hooks
   .description('Wire this harness to route registered questions to your devices')
   .option(
     '--harness <name>',
-    'claude-code | codex | cursor | opencode (default: detected)',
+    'claude-code | codex | cursor | opencode (default: every detected harness)',
   )
   .option('--global', 'install for every project instead of just this one')
   .action((opts: { harness?: string; global?: boolean }) => {
@@ -531,7 +525,7 @@ config
     'Set a configuration value (choose a layer interactively; unattended defaults machine-global and requires --yes)',
   )
   .option('--project', 'write to the shared .notifai/config.toml instead')
-  .option('--local', 'write to personal .notifai/config.local.toml (keep it gitignored)')
+  .option('--local', 'write a personal project preference on this machine (not in the repo)')
   .option('--session <id>', 'apply only to one session')
   .option('--yes', 'skip the confirmation gate')
   .action(
@@ -549,7 +543,7 @@ config
     'Remove a configuration value so the next layer or shipped default applies (choose a layer interactively; unattended defaults machine-global and requires --yes)',
   )
   .option('--project', 'remove from the shared .notifai/config.toml instead')
-  .option('--local', 'remove from personal .notifai/config.local.toml')
+  .option('--local', 'remove a personal project preference stored on this machine')
   .option('--session <id>', 'remove from one session')
   .option('--yes', 'skip the confirmation gate')
   .action(

package/src/native-skills.test.ts

@@ -0,0 +1,75 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { nativeSkills } from './native-skills.js'
+
+function writeLock(file: string, ref: string): void {
+  mkdirSync(path.dirname(file), { recursive: true })
+  writeFileSync(
+    file,
+    `${JSON.stringify({
+      version: 1,
+      skills: {
+        notifai: {
+          source: 'Raidiant-io/notifai',
+          sourceType: 'github',
+          sourceUrl: 'https://github.com/Raidiant-io/notifai.git',
+          ref,
+        },
+      },
+    })}\n`,
+  )
+}
+
+describe('nativeSkills.list', () => {
+  it('reads the project lock file instead of spawning npx', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-skills-project-'))
+    writeLock(path.join(cwd, 'skills-lock.json'), 'v0.5.1')
+
+    const result = await nativeSkills.list('project', cwd, { PATH: '/nonexistent' })
+    expect(result.error).toBeUndefined()
+    expect(result.skills).toEqual([
+      expect.objectContaining({
+        name: 'notifai',
+        scope: 'project',
+        source: 'Raidiant-io/notifai',
+        sourceType: 'github',
+        ref: 'v0.5.1',
+      }),
+    ])
+  })
+
+  it('reads the XDG global lock file instead of spawning npx', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-skills-xdg-'))
+    const state = path.join(cwd, 'state')
+    writeLock(path.join(state, 'skills', '.skill-lock.json'), 'v0.4.0')
+
+    const result = await nativeSkills.list('global', cwd, {
+      PATH: '/nonexistent',
+      XDG_STATE_HOME: state,
+    })
+    expect(result.error).toBeUndefined()
+    expect(result.skills).toEqual([
+      expect.objectContaining({ name: 'notifai', scope: 'global', ref: 'v0.4.0' }),
+    ])
+  })
+
+  it('falls back to the home-directory global lock', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-skills-home-'))
+    const home = path.join(cwd, 'home')
+    writeLock(path.join(home, '.agents', '.skill-lock.json'), 'v0.3.0')
+
+    const result = await nativeSkills.list('global', cwd, { PATH: '/nonexistent', HOME: home })
+    expect(result.error).toBeUndefined()
+    expect(result.skills).toEqual([
+      expect.objectContaining({ name: 'notifai', scope: 'global', ref: 'v0.3.0' }),
+    ])
+  })
+
+  it('treats a missing lock as an empty inventory, not an installer error', async () => {
+    const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-skills-missing-'))
+    const result = await nativeSkills.list('project', cwd, { PATH: '/nonexistent' })
+    expect(result).toEqual({ skills: [] })
+  })
+})