@raidiant/notifai 10.1.1 → 10.1.3

package/src/main-run.ts

@@ -1,45 +0,0 @@
-/**
- * Everything the CLI needs to actually run a command.
- *
- * Separate from `main.ts` so that the Node floor check there can decide
- * whether this file is safe to parse at all: a static import would be hoisted
- * above the check and fail first on the very runtimes the check exists to
- * turn away.
- */
-import { realIo, type CommandDeps } from './commands.js'
-import { defaultCredentialStore } from './credentials.js'
-import { nativeSkills } from './native-skills.js'
-import { argvFlagNames, bootstrapLogger } from './logging.js'
-import { buildProgram } from './program.js'
-import { spawnQuestionSettlement } from './question-settlement-process.js'
-
-/**
- * The local record for this invocation.
- *
- * Built before the command tree so that the very first thing recorded is the
- * command starting — including for a command that goes on to fail before it has
- * resolved anything. It configures itself from disk and disables itself if it
- * cannot write, so nothing below has to handle it failing.
- */
-const logger = bootstrapLogger()
-
-const deps: CommandDeps = {
-  io: realIo(),
-  store: defaultCredentialStore(),
-  env: process.env,
-  cwd: process.cwd(),
-  nativeSkills,
-  spawnQuestionSettlement,
-  logger,
-}
-
-const startedAt = Date.now()
-process.on('exit', (code) => {
-  logger.info('cli.end', {
-    exit: code,
-    duration_ms: Date.now() - startedAt,
-    flags: argvFlagNames(process.argv.slice(2)),
-  })
-})
-
-await buildProgram(deps).parseAsync(process.argv)

package/src/main.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-import { belowNodeFloor, nodeFloorMessage } from './node-floor.js'
-
-// Before anything else is parsed. `node-floor.js` imports nothing and uses no
-// syntax newer than the floor it checks, so it can report on the runtimes that
-// would otherwise fail somewhere in a dependency with no mention of Notifai.
-if (belowNodeFloor(process.version)) {
-  for (const line of nodeFloorMessage(process.version)) process.stderr.write(`${line}\n`)
-  process.exit(2)
-}
-
-await import('./main-run.js')

package/src/native-skills.test.ts

@@ -1,115 +0,0 @@
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { describe, expect, it } from 'vitest'
-import { SKILLS_INSTALLER_SPEC, nativeSkills, skillsAddArgv, skillsRemoveArgv } 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('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-'))
-    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: [] })
-  })
-})

package/src/native-skills.ts

@@ -1,162 +0,0 @@
-import { spawn } from 'node:child_process'
-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'
-
-/** The installer-managed evidence needed by Notifai readiness. */
-export interface NativeSkill {
-  name: string
-  scope: SkillScope
-  path: string
-  source: string | null
-  sourceType: string | null
-  sourceUrl: string | null
-  ref: string | null
-}
-
-export interface SkillsListResult {
-  skills: NativeSkill[]
-  error?: string
-}
-
-export interface SkillsAddOptions {
-  source: string
-  skill: string
-  scope?: SkillScope
-  cwd: string
-  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>
-}
-
-interface LockEntry {
-  source?: unknown
-  sourceType?: unknown
-  sourceUrl?: unknown
-  ref?: unknown
-  skillPath?: unknown
-}
-
-interface LockFile {
-  skills?: Record<string, LockEntry>
-}
-
-function skillLockPath(scope: SkillScope, cwd: string, env: NodeJS.ProcessEnv): string {
-  if (scope === 'project') return path.join(cwd, 'skills-lock.json')
-  const stateHome = env['XDG_STATE_HOME']
-  return stateHome !== undefined && stateHome !== ''
-    ? path.join(stateHome, 'skills', '.skill-lock.json')
-    : path.join(accountHome(env), '.agents', '.skill-lock.json')
-}
-
-function readLock(scope: SkillScope, cwd: string, env: NodeJS.ProcessEnv): LockFile {
-  const file = skillLockPath(scope, cwd, env)
-  if (!existsSync(file)) return {}
-  try {
-    const parsed = JSON.parse(readFileSync(file, 'utf8')) as LockFile
-    return parsed && typeof parsed === 'object' ? parsed : {}
-  } catch {
-    return {}
-  }
-}
-
-function conventionalSkillPath(
-  scope: SkillScope,
-  name: string,
-  cwd: string,
-  env: NodeJS.ProcessEnv,
-): string {
-  if (scope === 'project') return path.join(cwd, '.agents', 'skills', name)
-  return path.join(accountHome(env), '.agents', 'skills', name)
-}
-
-function skillsFromLock(scope: SkillScope, cwd: string, env: NodeJS.ProcessEnv): NativeSkill[] {
-  const lock = readLock(scope, cwd, env)
-  return Object.entries(lock.skills ?? {}).flatMap(([name, entry]): NativeSkill[] => {
-    if (entry === null || typeof entry !== 'object') return []
-    return [
-      {
-        name,
-        scope,
-        path:
-          typeof entry.skillPath === 'string' && entry.skillPath !== ''
-            ? entry.skillPath
-            : conventionalSkillPath(scope, name, cwd, env),
-        source: typeof entry.source === 'string' ? entry.source : null,
-        sourceType: typeof entry.sourceType === 'string' ? entry.sourceType : null,
-        sourceUrl: typeof entry.sourceUrl === 'string' ? entry.sourceUrl : null,
-        ref: typeof entry.ref === 'string' ? entry.ref : null,
-      },
-    ]
-  })
-}
-
-function run(args: string[], options: { cwd: string; env: NodeJS.ProcessEnv }): Promise<number> {
-  return new Promise((resolve) => {
-    const launch = npxLaunch(args, options)
-    const child = spawn(launch.file, launch.args, launch.options)
-    child.on('error', () => resolve(1))
-    child.on('exit', (code) => resolve(code ?? 1))
-  })
-}
-
-/** 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) {
-    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) {
-    // Presence is already on disk. `npx skills list` takes seconds and cannot
-    // change whether the notifai skill is installed — the lock file is what
-    // the installer itself consults.
-    return { skills: skillsFromLock(scope, cwd, env) }
-  },
-}

package/src/node-floor.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { NODE_MAJOR_FLOOR, belowNodeFloor, nodeFloorMessage, nodeMajor } from './node-floor.js'
-
-describe('the Node runtime floor', () => {
-  it('turns away a runtime below the floor', () => {
-    expect(belowNodeFloor('v20.11.1')).toBe(true)
-    expect(belowNodeFloor('v18.0.0')).toBe(true)
-  })
-
-  it('admits the floor and everything above it', () => {
-    expect(belowNodeFloor(`v${NODE_MAJOR_FLOOR}.0.0`)).toBe(false)
-    expect(belowNodeFloor('v24.3.0')).toBe(false)
-  })
-
-  it('does not strand a reader whose version it cannot read', () => {
-    expect(nodeMajor('bun-1.2')).toBeNull()
-    expect(belowNodeFloor('bun-1.2')).toBe(false)
-  })
-
-  it('says what is wrong and exactly one thing to do', () => {
-    const [problem, next] = nodeFloorMessage('v20.11.1')
-    expect(problem).toContain('Node 22 or newer')
-    expect(problem).toContain('v20.11.1')
-    expect(next).toMatch(/^next: /)
-    expect(next).toContain('nodejs.org')
-  })
-})

package/src/node-floor.ts

@@ -1,37 +0,0 @@
-/**
- * The Node version this CLI needs, asserted before anything else loads.
- *
- * `engines` in package.json is advisory: npm prints a warning at install time
- * and runs the binary anyway. So a reader on an older Node met a parser or
- * module error naming a file they did not write, with no mention of Notifai,
- * of Node, or of anything to do about it.
- *
- * This module is deliberately plain — no imports, no syntax newer than the
- * floor it is checking — so it can run and report on the runtimes it exists to
- * turn away. Everything else is loaded after it passes.
- */
-
-export const NODE_MAJOR_FLOOR = 22
-
-/** The major from a `process.version` string, or null when unrecognisable. */
-export function nodeMajor(version: string): number | null {
-  const match = /^v?(\d+)\./.exec(version)
-  if (match === null) return null
-  const major = Number(match[1])
-  return Number.isFinite(major) ? major : null
-}
-
-export function belowNodeFloor(version: string): boolean {
-  const major = nodeMajor(version)
-  // An unrecognisable version is not evidence of an old runtime, and refusing
-  // to run on one would strand a reader whose Node is fine.
-  return major !== null && major < NODE_MAJOR_FLOOR
-}
-
-/** One sentence for what is wrong, one for what to do about it. */
-export function nodeFloorMessage(version: string): string[] {
-  return [
-    `Notifai needs Node ${NODE_MAJOR_FLOOR} or newer; this is Node ${version}.`,
-    `next: install Node ${NODE_MAJOR_FLOOR}+ (https://nodejs.org), then run this again.`,
-  ]
-}

package/src/onboarding-docs.test.ts

@@ -1,25 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { describe, expect, it } from 'vitest'
-
-const publicReadme = readFileSync(new URL('../../../README.md', import.meta.url), 'utf8')
-const cliReadme = readFileSync(new URL('../README.md', import.meta.url), 'utf8')
-
-describe('public onboarding docs', () => {
-  it('installs the CLI before the first quick-start invocation', () => {
-    const using = publicReadme.slice(publicReadme.indexOf('## Using it'))
-    const install = using.indexOf('npm install -g @raidiant/notifai')
-    const firstInvocation = using.search(/^notifai(?:\s|$)/m)
-
-    expect(install).toBeGreaterThan(0)
-    expect(firstInvocation).toBeGreaterThan(install)
-    expect(using.slice(install, firstInvocation)).toContain('@raidiant/notifai')
-  })
-
-  it('states the active Android external-test boundary without promising a public release', () => {
-    const harnesses = cliReadme.slice(cliReadme.indexOf('## Agent harnesses'))
-
-    expect(harnesses).toMatch(/Android Companion App is active[\s\S]*external testing/i)
-    expect(harnesses).toMatch(/Firebase App Distribution/i)
-    expect(harnesses).toMatch(/not a\s+public release or a Google Play promise/i)
-  })
-})