@raidiant/notifai 7.0.2 → 9.0.0

package/src/native-skills.test.ts

@@ -2,7 +2,7 @@ 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'
+import { SKILLS_INSTALLER_SPEC, nativeSkills, skillsAddArgv, skillsRemoveArgv } from './native-skills.js'
 
 function writeLock(file: string, ref: string): void {
   mkdirSync(path.dirname(file), { recursive: true })
@@ -22,6 +22,46 @@ function writeLock(file: string, ref: string): void {
   )
 }
 
+describe('skillsAddArgv', () => {
+  it('pins the installer package to an exact reviewed version', () => {
+    const argv = skillsAddArgv({
+      source: 'Raidiant-io/notifai#v8.0.0',
+      skill: 'notifai',
+      cwd: '/tmp',
+      env: {},
+    })
+    expect(SKILLS_INSTALLER_SPEC).toMatch(/^skills@\d+\.\d+\.\d+$/)
+    expect(argv).toEqual([
+      '-y',
+      SKILLS_INSTALLER_SPEC,
+      'add',
+      'Raidiant-io/notifai#v8.0.0',
+      '--skill',
+      'notifai',
+    ])
+    expect(argv).not.toContain('skills')
+  })
+
+  it('uninstalls one skill in the named scope without a prompt', () => {
+    expect(
+      skillsRemoveArgv({
+        skill: 'notifai',
+        scope: 'project',
+        cwd: '/tmp',
+        env: {},
+      }),
+    ).toEqual(['-y', SKILLS_INSTALLER_SPEC, 'remove', 'notifai', '--yes'])
+    expect(
+      skillsRemoveArgv({
+        skill: 'notifai',
+        scope: 'global',
+        cwd: '/tmp',
+        env: {},
+      }),
+    ).toEqual(['-y', SKILLS_INSTALLER_SPEC, 'remove', 'notifai', '--global', '--yes'])
+  })
+})
+
 describe('nativeSkills.list', () => {
   it('reads the project lock file instead of spawning npx', async () => {
     const cwd = mkdtempSync(path.join(os.tmpdir(), 'notifai-skills-project-'))

package/src/native-skills.ts

@@ -3,6 +3,14 @@ import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { accountHome, npxLaunch } from './platform.js'
 
+/**
+ * Exact reviewed version of the external `skills` installer.
+ *
+ * The GitHub skill source stays the immutable CLI version tag. The installer
+ * program that fetches it must not float on `latest`.
+ */
+export const SKILLS_INSTALLER_SPEC = 'skills@1.5.23'
+
 /** The two scopes offered by the skills installer. */
 export type SkillScope = 'project' | 'global'
 
@@ -30,9 +38,18 @@ export interface SkillsAddOptions {
   env: NodeJS.ProcessEnv
 }
 
+export interface SkillsRemoveOptions {
+  skill: string
+  scope: SkillScope
+  cwd: string
+  env: NodeJS.ProcessEnv
+}
+
 export interface NativeSkills {
   /** Launch the native interactive `npx skills add` flow. */
   add(options: SkillsAddOptions): Promise<number>
+  /** Uninstall one installer-managed skill in one scope. */
+  remove(options: SkillsRemoveOptions): Promise<number>
   /** Read installer-managed inventory from lock files. Does not spawn npx. */
   list(scope: SkillScope, cwd: string, env: NodeJS.ProcessEnv): Promise<SkillsListResult>
 }
@@ -108,15 +125,32 @@ function run(args: string[], options: { cwd: string; env: NodeJS.ProcessEnv }):
   })
 }
 
+/** argv for `npx`, including the pinned installer spec. */
+export function skillsAddArgv(options: SkillsAddOptions): string[] {
+  const args = ['-y', SKILLS_INSTALLER_SPEC, 'add', options.source, '--skill', options.skill]
+  if (options.scope === 'global') args.push('--global')
+  // An explicit scope is the unattended contract. Native `--yes` keeps all
+  // remaining installer prompts non-interactive after the scope is chosen.
+  if (options.scope !== undefined) args.push('--yes')
+  return args
+}
+
+/** argv for uninstalling one skill in one installer scope. */
+export function skillsRemoveArgv(options: SkillsRemoveOptions): string[] {
+  const args = ['-y', SKILLS_INSTALLER_SPEC, 'remove', options.skill]
+  if (options.scope === 'global') args.push('--global')
+  args.push('--yes')
+  return args
+}
+
 /** The only process/filesystem adapter Notifai needs for the external installer. */
 export const nativeSkills: NativeSkills = {
   async add(options) {
-    const args = ['-y', 'skills', 'add', options.source, '--skill', options.skill]
-    if (options.scope === 'global') args.push('--global')
-    // An explicit scope is the unattended contract. Native `--yes` keeps all
-    // remaining installer prompts non-interactive after the scope is chosen.
-    if (options.scope !== undefined) args.push('--yes')
-    return run(args, { cwd: options.cwd, env: options.env })
+    return run(skillsAddArgv(options), { cwd: options.cwd, env: options.env })
+  },
+
+  async remove(options) {
+    return run(skillsRemoveArgv(options), { cwd: options.cwd, env: options.env })
   },
 
   async list(scope, cwd, env) {

package/src/opencode-plugin.ts

@@ -1,6 +1,7 @@
 import path from 'node:path'
 import { hookHostPlatform, type HookHostPlatform } from './hook-adapter.js'
 import { configHome } from './install-hooks.js'
+import { SESSION_ACTIVATION_CONTEXT } from './session-activation.js'
 
 /**
  * The OpenCode adapter.
@@ -31,7 +32,7 @@ export const OPENCODE_PLUGIN_MARKER = '// notifai managed opencode plugin'
 export const OPENCODE_PLUGIN_FILENAME = 'notifai.js'
 
 /** Bump when an installed generated file must be rewritten to remain functional. */
-const OPENCODE_ADAPTER_VERSION = 8
+const OPENCODE_ADAPTER_VERSION = 10
 
 export function opencodePluginDir(
   global: boolean,
@@ -103,6 +104,7 @@ import { spawn } from "node:child_process"
 ${nodeConstant}const ADAPTER = ${JSON.stringify(adapterPath)}
 const TIMEOUT_MS = ${timeoutSeconds * 1000}
 const ADAPTER_VERSION = ${OPENCODE_ADAPTER_VERSION}
+const SESSION_ACTIVATION_CONTEXT = ${JSON.stringify(SESSION_ACTIVATION_CONTEXT)}
 const PENDING_SESSION_TITLE =
   /^New session(?: *- *[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:[.][0-9]+)?Z)?$/i
 
@@ -158,6 +160,17 @@ export const NotifAIPlugin = async ({ directory, client }) => {
   const cwd = typeof directory === "string" && directory.length > 0 ? directory : process.cwd()
 
   return {
+    /** Model-visible activation, independent of CLI setup and delivery state. */
+    "experimental.chat.system.transform": async (input, output) => {
+      const sessionID = input?.sessionID
+      if (typeof sessionID !== "string" || sessionID.length === 0) return
+      if (output.system.length === 0) {
+        output.system.push(SESSION_ACTIVATION_CONTEXT)
+      } else {
+        output.system[0] = output.system[0] + "\\n\\n" + SESSION_ACTIVATION_CONTEXT
+      }
+    },
+
     /** Exact active-harness identity and first-party title for agent shell commands. */
     "shell.env": async (input, output) => {
       output.env.NOTIFAI_ACTIVE_HARNESS = "opencode"

package/src/program.test.ts

@@ -0,0 +1,237 @@
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { buildProgram, type ProgramRunners } from './program.js'
+import type { CommandDeps } from './commands.js'
+
+/**
+ * The layer these tests own is the argv boundary: what a real command line
+ * turns into by the time a command implementation receives it. Collector
+ * defaults, `--no-wait` disentangling, `--body-file` reading — none of that is
+ * visible to the unit tests on the commands themselves, and it used to be
+ * covered by nothing but reading `program.ts` with human eyes.
+ */
+
+class ExitSentinel extends Error {
+  constructor(readonly code: number) {
+    super(`exit ${code}`)
+  }
+}
+
+function makeDeps(): CommandDeps & { outLines: string[]; errLines: string[] } {
+  const outLines: string[] = []
+  const errLines: string[] = []
+  return {
+    io: {
+      out: (line: string) => outLines.push(line),
+      err: (line: string) => errLines.push(line),
+      confirm: async () => false,
+      openUrl: () => {},
+    },
+    store: {
+      load: () => null,
+      save: () => {},
+      clear: () => {},
+      describe: () => 'test credential store',
+    },
+    env: {},
+    cwd: os.tmpdir(),
+    outLines,
+    errLines,
+  }
+}
+
+/**
+ * Parse a real command line and capture what would have been dispatched.
+ * `exit` throws so post-exit code cannot run — the same property
+ * `process.exit` gives production.
+ */
+async function parse(
+  argv: string[],
+  runners: Partial<ProgramRunners>,
+  deps = makeDeps(),
+): Promise<{ exitCode: number | undefined; deps: ReturnType<typeof makeDeps> }> {
+  let exitCode: number | undefined
+  const program = buildProgram(deps, {
+    runners,
+    exit: (code: number) => {
+      exitCode = code
+      throw new ExitSentinel(code)
+    },
+  })
+  try {
+    await program.parseAsync(['node', 'notifai', ...argv])
+  } catch (err) {
+    if (!(err instanceof ExitSentinel)) throw err
+  }
+  return { exitCode, deps }
+}
+
+describe('program argv parsing', () => {
+  it('maps a full send command line onto sendCommand flags', async () => {
+    let seen: Record<string, unknown> | undefined
+    const { exitCode } = await parse(
+      [
+        'send',
+        '--kind', 'done',
+        '--title', 'Build finished',
+        '--body', 'All green.',
+        '--choice', 'Ship it',
+        '--choice', 'Hold',
+        '--multi',
+        '--reply',
+        '--reply-timeout', '30',
+      ],
+      { send: (async (_deps, flags) => ((seen = flags as Record<string, unknown>), 0)) as ProgramRunners['send'] },
+    )
+    expect(exitCode).toBe(0)
+    expect(seen).toMatchObject({
+      kind: 'done',
+      title: 'Build finished',
+      body: 'All green.',
+      choice: ['Ship it', 'Hold'],
+      multi: true,
+      reply: true,
+      replyTimeout: 30,
+      noWait: false,
+    })
+  })
+
+  it('drops empty collector defaults so "not passed" stays absent', async () => {
+    let seen: Record<string, unknown> | undefined
+    await parse(
+      ['send', '--kind', 'update', '--title', 'T', '--body', 'B'],
+      { send: (async (_deps, flags) => ((seen = flags as Record<string, unknown>), 0)) as ProgramRunners['send'] },
+    )
+    expect(seen).toBeDefined()
+    expect(seen).not.toHaveProperty('choice')
+    expect(seen).not.toHaveProperty('image')
+    expect(seen).not.toHaveProperty('imageAlt')
+    expect(seen).not.toHaveProperty('wait')
+  })
+
+  it('maps init --setup-scope onto the command flags', async () => {
+    let seen: Record<string, unknown> | undefined
+    const { exitCode } = await parse(
+      ['init', '--skills', '--setup-scope', 'global', '--no-hooks'],
+      { init: (async (_deps, flags) => ((seen = flags as Record<string, unknown>), 0)) as ProgramRunners['init'] },
+    )
+    expect(exitCode).toBe(0)
+    expect(seen).toMatchObject({ skills: true, setupScope: 'global', hooks: false })
+  })
+
+  it('disentangles --no-wait and --wait from their shared commander flag', async () => {
+    const capture = (sink: Record<string, unknown>[]): ProgramRunners['send'] =>
+      (async (_deps, flags) => (sink.push(flags as Record<string, unknown>), 0)) as ProgramRunners['send']
+    const seen: Record<string, unknown>[] = []
+    await parse(['send', '--kind', 'update', '--title', 'T', '--body', 'B', '--no-wait'], { send: capture(seen) })
+    await parse(['send', '--kind', 'update', '--title', 'T', '--body', 'B', '--wait', '5'], { send: capture(seen) })
+    expect(seen[0]).toMatchObject({ noWait: true })
+    expect(seen[0]).not.toHaveProperty('wait')
+    expect(seen[1]).toMatchObject({ noWait: false, wait: 5 })
+  })
+
+  it('reads --body-file and refuses it alongside --body', async () => {
+    const dir = mkdtempSync(path.join(os.tmpdir(), 'notifai-program-test-'))
+    const file = path.join(dir, 'body.md')
+    writeFileSync(file, 'From a file.\n')
+    let seen: Record<string, unknown> | undefined
+    const send = (async (_deps, flags) => ((seen = flags as Record<string, unknown>), 0)) as ProgramRunners['send']
+
+    const ok = await parse(['send', '--kind', 'update', '--title', 'T', '--body-file', file], { send })
+    expect(ok.exitCode).toBe(0)
+    expect(seen).toMatchObject({ body: 'From a file.\n' })
+    expect(seen).not.toHaveProperty('bodyFile')
+
+    const both = await parse(
+      ['send', '--kind', 'update', '--title', 'T', '--body', 'B', '--body-file', file],
+      { send },
+    )
+    expect(both.exitCode).toBe(2)
+    expect(both.deps.errLines.join('\n')).toContain('either --body or --body-file')
+
+    const missing = await parse(
+      ['send', '--kind', 'update', '--title', 'T', '--body-file', path.join(dir, 'absent.md')],
+      { send },
+    )
+    expect(missing.exitCode).toBe(2)
+    expect(missing.deps.errLines.join('\n')).toContain('Could not read')
+  })
+
+  it('builds ask flags without empty collectors and passes the question through', async () => {
+    let seenQuestion: string | undefined
+    let seenFlags: Record<string, unknown> | undefined
+    const ask = (async (_deps, question, flags) => {
+      seenQuestion = question
+      seenFlags = flags as Record<string, unknown>
+      return 0
+    }) as ProgramRunners['ask']
+
+    await parse(
+      ['ask', 'Deploy where?', '--choice', 'Staging', '--choice', 'Production', '--session-label', 'release run', '--json'],
+      { ask },
+    )
+    expect(seenQuestion).toBe('Deploy where?')
+    expect(seenFlags).toEqual({
+      choice: ['Staging', 'Production'],
+      sessionLabel: 'release run',
+      json: true,
+    })
+
+    await parse(['ask', 'Free text?'], { ask })
+    expect(seenFlags).toEqual({})
+  })
+
+  it('rejects --no-block as unknown: the flag is gone, not tombstoned', async () => {
+    const { exitCode, deps } = await parse(
+      ['send', '--kind', 'update', '--title', 'T', '--body', 'B', '--no-block'],
+      { send: (async () => 0) as ProgramRunners['send'] },
+    )
+    expect(exitCode).toBe(2)
+    expect(deps.errLines).toHaveLength(0)
+  })
+
+  it('names an unknown command and exits 2', async () => {
+    const { exitCode, deps } = await parse(['sendd'], {})
+    expect(exitCode).toBe(2)
+    expect(deps.errLines.join('\n')).toContain('Unknown command "sendd"')
+    expect(deps.errLines.join('\n')).toContain('send')
+  })
+
+  it('rejects send --event now that the public event field is gone', async () => {
+    const { exitCode, deps } = await parse(
+      ['send', '--kind', 'done', '--title', 'T', '--body', 'B', '--event', 'tests_passed'],
+      { send: (async () => 0) as ProgramRunners['send'] },
+    )
+    expect(exitCode).toBe(2)
+    expect(deps.errLines).toHaveLength(0)
+  })
+
+  it('drops the empty --event collector for logs', async () => {
+    let seen: Record<string, unknown> | undefined
+    const logs = ((_deps, flags) => ((seen = flags as Record<string, unknown>), 0)) as ProgramRunners['logs']
+    await parse(['logs'], { logs })
+    expect(seen).not.toHaveProperty('event')
+    await parse(['logs', '--event', 'send.submitted'], { logs })
+    expect(seen).toMatchObject({ event: ['send.submitted'] })
+  })
+
+  it('passes close --pending without inventing a request id', async () => {
+    let seenId: string | undefined
+    let seenFlags: Record<string, unknown> | undefined
+    const close = (async (_deps, requestId, flags) => {
+      seenId = requestId
+      seenFlags = flags as Record<string, unknown>
+      return 0
+    }) as ProgramRunners['close']
+
+    await parse(['close', '--pending', '--json'], { close })
+    expect(seenId).toBeUndefined()
+    expect(seenFlags).toEqual({ pending: true, json: true })
+
+    await parse(['close', 'req_abc'], { close })
+    expect(seenId).toBe('req_abc')
+    expect(seenFlags).toEqual({})
+  })
+})