@raidiant/notifai 10.1.1 → 10.1.2

package/src/invocation-context.test.ts

@@ -1,352 +0,0 @@
-import { mkdtempSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { describe, expect, it } from 'vitest'
-import {
-  buildSourceContext,
-  inferInvocationContext,
-  portableBasename,
-  projectSlugFrom,
-  truncateContext,
-  type GitCommand,
-} from './invocation-context.js'
-
-function fixtureGit(values: Record<string, string | null>): GitCommand {
-  return (_cwd, args) => values[args.join(' ')] ?? null
-}
-
-function stateEnv(overrides: NodeJS.ProcessEnv = {}): NodeJS.ProcessEnv {
-  return {
-    XDG_STATE_HOME: mkdtempSync(path.join(os.tmpdir(), 'notifai-source-context-')),
-    ...overrides,
-  }
-}
-
-describe('projectSlugFrom', () => {
-  it.each([
-    ['My Project', 'my-project'],
-    ['.Hidden Repo', 'hidden-repo'],
-    ['API_v2.0', 'api_v2.0'],
-    ['---', null],
-    ['项目', null],
-  ])('turns %s into %s', (name, expected) => {
-    expect(projectSlugFrom(name)).toBe(expected)
-  })
-
-  it('keeps the Project identifier inside its 64-character bound', () => {
-    expect(projectSlugFrom(`repo-${'x'.repeat(100)}`)).toHaveLength(64)
-  })
-})
-
-describe('portableBasename', () => {
-  it.each([
-    ['/Users/person/code/notifai/', 'notifai'],
-    ['C:\\Users\\Person\\code\\notifai\\', 'notifai'],
-    ['\\\\server\\share\\worktrees\\release\\', 'release'],
-  ])('extracts the basename from %s', (value, expected) => {
-    expect(portableBasename(value)).toBe(expected)
-  })
-})
-
-describe('inferInvocationContext', () => {
-  it('uses the common-directory parent for a repository from a nested cwd', () => {
-    const context = inferInvocationContext(
-      '/code/Signal Garden/packages/api',
-      fixtureGit({
-        'rev-parse --git-common-dir': '../../.git',
-        'rev-parse --git-dir': '../../.git',
-        'rev-parse --show-toplevel': '/code/Signal Garden',
-        'rev-parse --abbrev-ref HEAD': 'feature/alerts',
-      }),
-    )
-    expect(context).toEqual({ project: 'signal-garden', branch: 'feature/alerts' })
-  })
-
-  it('keeps one Project across linked worktrees and exposes only the worktree basename', () => {
-    const context = inferInvocationContext(
-      '/Users/name/worktrees/notifai-release/apps/cli',
-      fixtureGit({
-        'rev-parse --git-common-dir': '/Users/name/code/notifai/.git',
-        'rev-parse --git-dir': '/Users/name/code/notifai/.git/worktrees/notifai-release',
-        'rev-parse --show-toplevel': '/Users/name/worktrees/notifai-release/',
-        'rev-parse --abbrev-ref HEAD': 'release/content',
-      }),
-    )
-    expect(context).toEqual({
-      project: 'notifai',
-      branch: 'release/content',
-      worktree: 'notifai-release',
-    })
-    expect(JSON.stringify(context)).not.toContain('/Users/name')
-  })
-
-  it('handles drive-letter paths and compares them case-insensitively', () => {
-    const context = inferInvocationContext(
-      'D:\\Worktrees\\Alerts\\src',
-      fixtureGit({
-        'rev-parse --git-common-dir': 'C:\\Code\\Notifai\\.git\\',
-        'rev-parse --git-dir': 'c:\\code\\notifai\\.git\\worktrees\\Alerts',
-        'rev-parse --show-toplevel': 'D:\\Worktrees\\Alerts\\',
-        'rev-parse --abbrev-ref HEAD': 'feature/windows',
-      }),
-    )
-    expect(context).toEqual({
-      project: 'notifai',
-      branch: 'feature/windows',
-      worktree: 'Alerts',
-    })
-    expect(JSON.stringify(context)).not.toContain('D:\\Worktrees')
-    expect(JSON.stringify(context)).not.toContain('C:\\Code')
-  })
-
-  it('handles a UNC common directory and trailing separators', () => {
-    const context = inferInvocationContext(
-      '\\\\server\\share\\trees\\topic\\src',
-      fixtureGit({
-        'rev-parse --git-common-dir': '\\\\server\\share\\Notifai\\.git\\',
-        'rev-parse --git-dir': '\\\\server\\share\\Notifai\\.git\\worktrees\\topic\\',
-        'rev-parse --show-toplevel': '\\\\server\\share\\trees\\topic\\',
-        'rev-parse --abbrev-ref HEAD': 'topic',
-      }),
-    )
-    expect(context).toEqual({ project: 'notifai', branch: 'topic', worktree: 'topic' })
-  })
-
-  it('falls back to the cwd basename outside Git', () => {
-    expect(inferInvocationContext('/tmp/My Scratch/', fixtureGit({}))).toEqual({
-      project: 'my-scratch',
-    })
-  })
-
-  it('omits an unusable Project instead of inventing one', () => {
-    expect(inferInvocationContext('/tmp/项目', fixtureGit({}))).toEqual({ project: null })
-  })
-
-  it('omits branch and worktree on detached HEAD in an ordinary checkout', () => {
-    expect(
-      inferInvocationContext(
-        '/code/repo',
-        fixtureGit({
-          'rev-parse --git-common-dir': '.git',
-          'rev-parse --git-dir': '.git',
-          'rev-parse --show-toplevel': '/code/repo',
-          'rev-parse --abbrev-ref HEAD': 'HEAD',
-        }),
-      ),
-    ).toEqual({ project: 'repo' })
-  })
-
-  it('bounds branch and worktree display strings without leaking their parents', () => {
-    const longBranch = `feature/${'界'.repeat(140)}`
-    const longWorktree = `tree-${'x'.repeat(80)}`
-    const context = inferInvocationContext(
-      '/private/work/tree/src',
-      fixtureGit({
-        'rev-parse --git-common-dir': '/private/main/repo/.git',
-        'rev-parse --git-dir': '/private/main/repo/.git/worktrees/tree',
-        'rev-parse --show-toplevel': `/private/work/${longWorktree}`,
-        'rev-parse --abbrev-ref HEAD': longBranch,
-      }),
-    )
-    expect(Array.from(context.branch ?? '')).toHaveLength(128)
-    expect(Array.from(context.worktree ?? '')).toHaveLength(64)
-    expect(context.branch).toMatch(/…$/)
-    expect(context.worktree).toMatch(/…$/)
-    expect(JSON.stringify(context)).not.toContain('/private/')
-  })
-})
-
-describe('truncateContext', () => {
-  it('counts Unicode characters rather than UTF-16 code units', () => {
-    expect(truncateContext('A😀BC', 3)).toBe('A😀…')
-  })
-})
-
-describe('buildSourceContext', () => {
-  const invocation = { project: 'repo', branch: 'main', worktree: 'topic' }
-  const now = new Date(2026, 7, 20, 14, 5).getTime()
-
-  it('applies flag, environment, then inferred precedence per session field', () => {
-    const built = buildSourceContext({
-      env: stateEnv({
-        NOTIFAI_SESSION_ID: 'env-id',
-        NOTIFAI_SESSION_LABEL: 'Environment Label',
-      }),
-      invocation,
-      sessionId: 'flag-id',
-      sessionLabel: 'Flag Label',
-      activeHarness: { harness: 'claude-code', sessionId: 'flag-id' },
-      now,
-    })
-    expect(built).toEqual({
-      ok: true,
-      source: {
-        session_id: 'flag-id',
-        session_label: 'Flag Label',
-        harness: 'claude-code',
-        branch: 'main',
-        worktree: 'topic',
-      },
-    })
-  })
-
-  it('uses environment values ahead of an inferred exact session', () => {
-    expect(
-      buildSourceContext({
-        env: stateEnv({
-          NOTIFAI_SESSION_ID: 'env-id',
-          NOTIFAI_SESSION_LABEL: 'Environment Label',
-        }),
-        invocation: { project: 'repo' },
-        activeHarness: { harness: 'codex', sessionId: 'env-id' },
-        now,
-      }),
-    ).toEqual({
-      ok: true,
-      source: {
-        session_id: 'env-id',
-        session_label: 'Environment Label',
-        harness: 'codex',
-      },
-    })
-  })
-
-  it('uses and freezes a trusted harness-native title', () => {
-    const env = stateEnv()
-    const sessionId = 'opencode-thread'
-    expect(
-      buildSourceContext({
-        env,
-        invocation: { project: 'repo', branch: 'main' },
-        activeHarness: {
-          harness: 'opencode',
-          sessionId,
-          sessionLabel: 'Semantic session names',
-        },
-        now,
-      }),
-    ).toEqual({
-      ok: true,
-      source: {
-        session_id: sessionId,
-        session_label: 'Semantic session names',
-        harness: 'opencode',
-        branch: 'main',
-      },
-    })
-    expect(
-      buildSourceContext({
-        env,
-        invocation: { project: 'repo' },
-        activeHarness: { harness: 'opencode', sessionId, sessionLabel: 'Changed title' },
-        now: now + 1_000,
-      }),
-    ).toEqual({
-      ok: true,
-      source: {
-        session_id: sessionId,
-        session_label: 'Semantic session names',
-        harness: 'opencode',
-      },
-    })
-  })
-
-  it('does not freeze an OpenCode placeholder while its semantic title is pending', () => {
-    expect(
-      buildSourceContext({
-        env: stateEnv(),
-        invocation: { project: 'repo' },
-        activeHarness: {
-          harness: 'opencode',
-          sessionId: 'pending-session',
-          sessionLabelPending: true,
-        },
-        now,
-      }),
-    ).toEqual({
-      ok: false,
-      error:
-        "OpenCode is still generating this session's title; retry shortly or pass --session-label.",
-    })
-  })
-
-  it('uses a stable generated fallback when no semantic name exists', () => {
-    const env = stateEnv()
-    const sessionId = 'opaque-thread-1234567890'
-    const expected = {
-      ok: true,
-      source: {
-        session_id: sessionId,
-        session_label: 'Ivory Koala',
-        harness: 'opencode' as const,
-        branch: 'main',
-      },
-    }
-    expect(
-      buildSourceContext({
-        env,
-        invocation: { project: 'repo', branch: 'main' },
-        activeHarness: { harness: 'opencode', sessionId },
-        now,
-      }),
-    ).toEqual(expected)
-    expect(expected.source.session_label).not.toContain('1234567890')
-  })
-
-  it('does not borrow harness identity or title for an explicit different session id', () => {
-    expect(
-      buildSourceContext({
-        env: stateEnv(),
-        invocation: { project: 'repo' },
-        sessionId: 'other-session',
-        activeHarness: {
-          harness: 'claude-code',
-          sessionId: 'current-session',
-          sessionLabel: 'Current work',
-        },
-        now,
-      }),
-    ).toEqual({
-      ok: true,
-      source: {
-        session_id: 'other-session',
-        session_label: 'Golden Lynx',
-      },
-    })
-  })
-
-  it('does not emit a harness or label when no exact session id is available', () => {
-    expect(
-      buildSourceContext({
-        env: stateEnv(),
-        invocation: { project: 'repo', branch: 'main' },
-        activeHarness: { harness: 'cursor' },
-        now,
-      }),
-    ).toEqual({ ok: true, source: { branch: 'main' } })
-  })
-
-  it('ignores the deleted NOTIFAI_SESSION variable', () => {
-    expect(
-      buildSourceContext({
-        env: stateEnv({ NOTIFAI_SESSION: 'legacy-id' }),
-        invocation: { project: 'repo' },
-        now,
-      }),
-    ).toEqual({ ok: true })
-  })
-
-  it('rejects a display label without an exact session id', () => {
-    expect(
-      buildSourceContext({
-        env: stateEnv(),
-        invocation: { project: 'repo' },
-        sessionLabel: 'Unbound Label',
-        now,
-      }),
-    ).toEqual({
-      ok: false,
-      error: '--session-label (or NOTIFAI_SESSION_LABEL) needs an exact Agent Session id.',
-    })
-  })
-})

package/src/invocation-context.ts

@@ -1,197 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import path from 'node:path'
-import { type SourceContextT } from '@raidiant/notifai-protocol'
-import type { SourceContextHarness } from './harnesses.js'
-import { resolveSessionLabel } from './session-labels.js'
-
-export type GitCommand = (cwd: string, args: readonly string[]) => string | null
-
-const runGit: GitCommand = (cwd, args) => {
-  try {
-    return execFileSync('git', ['-C', cwd, ...args], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: 2_000,
-      windowsHide: true,
-    }).trim()
-  } catch {
-    return null
-  }
-}
-
-/** The useful, privacy-safe context inferred from one invocation directory. */
-export interface InvocationContext {
-  project: string | null
-  branch?: string
-  worktree?: string
-}
-
-/** Contract-valid Project slug, or null when the name has no safe characters. */
-export function projectSlugFrom(name: string): string | null {
-  const slug = name
-    .toLowerCase()
-    .replaceAll(/[^a-z0-9._-]+/g, '-')
-    .replaceAll(/^[^a-z0-9]+|[^a-z0-9._-]+$/g, '')
-    .slice(0, 64)
-  return slug.length > 0 && /^[a-z0-9]/.test(slug) ? slug : null
-}
-
-function usesWindowsPaths(...values: string[]): boolean {
-  return values.some((value) => /^[A-Za-z]:[\\/]/.test(value) || /^\\\\/.test(value))
-}
-
-function pathApi(...values: string[]): typeof path.posix | typeof path.win32 {
-  return usesWindowsPaths(...values) ? path.win32 : path.posix
-}
-
-/** Basename that can be fixture-tested for POSIX, drive, and UNC paths on any OS. */
-export function portableBasename(value: string): string {
-  const api = pathApi(value)
-  return api.basename(api.normalize(value))
-}
-
-function resolveGitPath(cwd: string, value: string): string {
-  const api = pathApi(cwd, value)
-  return api.isAbsolute(value) ? api.normalize(value) : api.resolve(cwd, value)
-}
-
-function samePath(left: string, right: string): boolean {
-  const api = pathApi(left, right)
-  const normalizedLeft = api.normalize(left)
-  const normalizedRight = api.normalize(right)
-  return api === path.win32
-    ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
-    : normalizedLeft === normalizedRight
-}
-
-/** Truncate a display string by Unicode characters and keep the ellipsis inside the bound. */
-export function truncateContext(value: string, maxLength: number): string {
-  const characters = Array.from(value)
-  if (characters.length <= maxLength) return value
-  return `${characters.slice(0, Math.max(0, maxLength - 1)).join('')}…`
-}
-
-/**
- * Infer stable Project identity plus branch/worktree display context.
- *
- * Linked worktrees share the parent of Git's common directory, while a non-Git
- * directory falls back to its own basename. Only basenames and branch names are
- * returned; no absolute path can leave this function.
- */
-export function inferInvocationContext(
-  cwd: string,
-  git: GitCommand = runGit,
-): InvocationContext {
-  const commonRaw = git(cwd, ['rev-parse', '--git-common-dir'])
-  if (commonRaw === null || commonRaw === '') {
-    return { project: projectSlugFrom(portableBasename(cwd)) }
-  }
-
-  const commonDir = resolveGitPath(cwd, commonRaw)
-  const api = pathApi(cwd, commonDir)
-  const gitDirRaw = git(cwd, ['rev-parse', '--git-dir'])
-  const topLevelRaw = git(cwd, ['rev-parse', '--show-toplevel'])
-  const linked =
-    gitDirRaw !== null &&
-    gitDirRaw !== '' &&
-    !samePath(resolveGitPath(cwd, gitDirRaw), commonDir)
-
-  // In an ordinary checkout the worktree root is the useful Project root. A
-  // linked worktree needs its shared repository identity instead: standard Git
-  // stores that in <main>/.git, while submodules and --separate-git-dir use a
-  // named common directory whose basename is the only stable, path-free label.
-  // Treating every common directory as `.git` would infer `modules` or `public`
-  // for submodules — an implementation detail, not the repository's identity.
-  const commonName = api.basename(commonDir)
-  const projectName = linked
-    ? commonName.toLowerCase() === '.git'
-      ? api.basename(api.dirname(commonDir))
-      : commonName
-    : topLevelRaw !== null && topLevelRaw !== ''
-      ? portableBasename(topLevelRaw)
-      : commonName.toLowerCase() === '.git'
-        ? api.basename(api.dirname(commonDir))
-        : commonName
-  const project = projectSlugFrom(projectName)
-
-  const branchRaw = git(cwd, ['rev-parse', '--abbrev-ref', 'HEAD'])
-  const branch =
-    branchRaw === null || branchRaw === '' || branchRaw === 'HEAD'
-      ? undefined
-      : truncateContext(branchRaw, 128)
-
-  const worktree =
-    linked && topLevelRaw !== null && topLevelRaw !== ''
-      ? truncateContext(portableBasename(topLevelRaw), 64)
-      : undefined
-
-  return {
-    project,
-    ...(branch !== undefined ? { branch } : {}),
-    ...(worktree !== undefined && worktree !== '' ? { worktree } : {}),
-  }
-}
-
-export interface SourceContextInput {
-  env: NodeJS.ProcessEnv
-  invocation: InvocationContext
-  sessionId?: string
-  sessionLabel?: string
-  activeHarness?: {
-    harness: SourceContextHarness
-    sessionId?: string
-    sessionLabel?: string
-    sessionLabelPending?: boolean
-  }
-  now?: number
-}
-
-export type SourceContextBuild =
-  | { ok: true; source?: SourceContextT }
-  | { ok: false; error: string }
-
-/** Resolve per-field Source Context precedence without fabricating Agent Session identity. */
-export function buildSourceContext(input: SourceContextInput): SourceContextBuild {
-  const sessionId =
-    input.sessionId ?? input.env['NOTIFAI_SESSION_ID'] ?? input.activeHarness?.sessionId
-  const explicitLabel = input.sessionLabel ?? input.env['NOTIFAI_SESSION_LABEL']
-  if (explicitLabel !== undefined && (sessionId === undefined || sessionId === '')) {
-    return {
-      ok: false,
-      error: '--session-label (or NOTIFAI_SESSION_LABEL) needs an exact Agent Session id.',
-    }
-  }
-  if (sessionId === '') {
-    return { ok: false, error: '--session-id must not be empty.' }
-  }
-
-  const activeOwnsSession =
-    sessionId !== undefined && input.activeHarness?.sessionId === sessionId
-  const harness = activeOwnsSession ? input.activeHarness?.harness : undefined
-  const label =
-    sessionId === undefined
-      ? undefined
-      : resolveSessionLabel({
-          env: input.env,
-          sessionId,
-          ...(harness === undefined ? {} : { harness }),
-          ...(explicitLabel === undefined ? {} : { explicitLabel }),
-          ...(activeOwnsSession && input.activeHarness?.sessionLabel !== undefined
-            ? { harnessLabel: input.activeHarness.sessionLabel }
-            : {}),
-          ...(activeOwnsSession && input.activeHarness?.sessionLabelPending === true
-            ? { harnessLabelPending: true }
-            : {}),
-          ...(input.now === undefined ? {} : { now: input.now }),
-        })
-  if (label !== undefined && !label.ok) return label
-
-  const source: SourceContextT = {
-    ...(sessionId !== undefined ? { session_id: sessionId } : {}),
-    ...(label !== undefined ? { session_label: label.label } : {}),
-    ...(harness !== undefined ? { harness } : {}),
-    ...(input.invocation.branch !== undefined ? { branch: input.invocation.branch } : {}),
-    ...(input.invocation.worktree !== undefined ? { worktree: input.invocation.worktree } : {}),
-  }
-  return Object.keys(source).length === 0 ? { ok: true } : { ok: true, source }
-}

package/src/logging-process-worker.test.ts

@@ -1,45 +0,0 @@
-import { existsSync, writeFileSync } from 'node:fs'
-import { describe, expect, it } from 'vitest'
-import { createLogger } from './logging.js'
-
-const worker = process.env['NOTIFAI_ROTATION_WORKER']
-
-if (worker === undefined) {
-  describe('rotation process worker', () => {
-    it('stays dormant outside the concurrency regression', () => {
-      expect(worker).toBeUndefined()
-    })
-  })
-} else {
-  describe('rotation process worker', () => {
-    it('writes one share of an overlapping log stream', async () => {
-      const readyPath = process.env['NOTIFAI_ROTATION_READY']!
-      const startPath = process.env['NOTIFAI_ROTATION_START']!
-      const records = Number(process.env['NOTIFAI_ROTATION_RECORDS'])
-      const maxBytes = Number(process.env['NOTIFAI_ROTATION_MAX_BYTES'])
-      const maxFiles = Number(process.env['NOTIFAI_ROTATION_MAX_FILES'])
-      writeFileSync(readyPath, 'ready')
-      // The parent's absolute deadline, not a countdown of this worker's own:
-      // the barrier fails for everyone at one instant, so a worker that started
-      // early cannot walk out on a parent still waiting for its last sibling.
-      const startDeadline = Number(process.env['NOTIFAI_ROTATION_DEADLINE'])
-      while (!existsSync(startPath)) {
-        if (Date.now() >= startDeadline) throw new Error('rotation parent never released the barrier')
-        await new Promise((resolve) => setTimeout(resolve, 2))
-      }
-
-      const logger = createLogger({
-        runId: `r_worker_${worker}`,
-        settings: { maxBytes, maxFiles },
-      })
-      for (let sequence = 0; sequence < records; sequence += 1) {
-        logger.info('cli.end', { worker, sequence, pad: 'p'.repeat(140) })
-        await new Promise((resolve) => setTimeout(resolve, 1))
-      }
-      // The sink switches itself off for the rest of a process the first time a
-      // write throws, so this is the whole point of the worker: every record it
-      // was given reached the shared file through the cross-process lock.
-      expect(logger.enabled, 'the shared-log sink switched itself off mid-run').toBe(true)
-    })
-  })
-}