@raidiant/notifai 10.1.0 → 10.1.2

package/src/main.ts

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-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'
-
-/**
- * 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,
-  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/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/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)
-  })
-})