subagent-cli 0.3.0 → 0.3.1

package/src/utils/crossProjectResume.ts

@@ -1,75 +0,0 @@
-import { sep } from 'path'
-import { getOriginalCwd } from '../bootstrap/state.js'
-import type { LogOption } from '../types/logs.js'
-import { quote } from './bash/shellQuote.js'
-import { getSessionIdFromLog } from './sessionStorage.js'
-
-export type CrossProjectResumeResult =
-  | {
-      isCrossProject: false
-    }
-  | {
-      isCrossProject: true
-      isSameRepoWorktree: true
-      projectPath: string
-    }
-  | {
-      isCrossProject: true
-      isSameRepoWorktree: false
-      command: string
-      projectPath: string
-    }
-
-/**
- * Check if a log is from a different project directory and determine
- * whether it's a related worktree or a completely different project.
- *
- * For same-repo worktrees, we can resume directly without requiring cd.
- * For different projects, we generate the cd command.
- */
-export function checkCrossProjectResume(
-  log: LogOption,
-  showAllProjects: boolean,
-  worktreePaths: string[],
-): CrossProjectResumeResult {
-  const currentCwd = getOriginalCwd()
-
-  if (!showAllProjects || !log.projectPath || log.projectPath === currentCwd) {
-    return { isCrossProject: false }
-  }
-
-  // Gate worktree detection to ants only for staged rollout
-  if (process.env.USER_TYPE !== 'ant') {
-    const sessionId = getSessionIdFromLog(log)
-    const command = `cd ${quote([log.projectPath])} && claude --resume ${sessionId}`
-    return {
-      isCrossProject: true,
-      isSameRepoWorktree: false,
-      command,
-      projectPath: log.projectPath,
-    }
-  }
-
-  // Check if log.projectPath is under a worktree of the same repo
-  const isSameRepo = worktreePaths.some(
-    wt => log.projectPath === wt || log.projectPath!.startsWith(wt + sep),
-  )
-
-  if (isSameRepo) {
-    return {
-      isCrossProject: true,
-      isSameRepoWorktree: true,
-      projectPath: log.projectPath,
-    }
-  }
-
-  // Different repo - generate cd command
-  const sessionId = getSessionIdFromLog(log)
-  const command = `cd ${quote([log.projectPath])} && claude --resume ${sessionId}`
-  return {
-    isCrossProject: true,
-    isSameRepoWorktree: false,
-    command,
-    projectPath: log.projectPath,
-  }
-}

package/src/utils/crypto.ts

@@ -1,13 +0,0 @@
-// Indirection point for the package.json "browser" field. When bun builds
-// browser-sdk.js with --target browser, this file is swapped for
-// crypto.browser.ts — avoiding a ~500KB crypto-browserify polyfill that Bun
-// would otherwise inline for `import ... from 'crypto'`. Node/bun builds use
-// this file unchanged.
-//
-// NOTE: `export { randomUUID } from 'crypto'` (re-export syntax) breaks under
-// bun-internal's bytecode compilation — the generated bytecode shows the
-// import but the binding doesn't link (`ReferenceError: randomUUID is not
-// defined`). The explicit import-then-export below produces a correct live
-// binding. See integration-tests-ant-native failure on PR #20957/#21178.
-import { randomUUID } from 'crypto'
-export { randomUUID }

package/src/utils/cwd.ts

@@ -1,32 +0,0 @@
-import { AsyncLocalStorage } from 'async_hooks'
-import { getCwdState, getOriginalCwd } from '../bootstrap/state.js'
-
-const cwdOverrideStorage = new AsyncLocalStorage<string>()
-
-/**
- * Run a function with an overridden working directory for the current async context.
- * All calls to pwd()/getCwd() within the function (and its async descendants) will
- * return the overridden cwd instead of the global one. This enables concurrent
- * agents to each see their own working directory without affecting each other.
- */
-export function runWithCwdOverride<T>(cwd: string, fn: () => T): T {
-  return cwdOverrideStorage.run(cwd, fn)
-}
-
-/**
- * Get the current working directory
- */
-export function pwd(): string {
-  return cwdOverrideStorage.getStore() ?? getCwdState()
-}
-
-/**
- * Get the current working directory or the original working directory if the current one is not available
- */
-export function getCwd(): string {
-  try {
-    return pwd()
-  } catch {
-    return getOriginalCwd()
-  }
-}

package/src/utils/debug.ts

@@ -1,268 +0,0 @@
-import { appendFile, mkdir, symlink, unlink } from 'fs/promises'
-import memoize from 'lodash-es/memoize.js'
-import { dirname, join } from 'path'
-import { getSessionId } from 'src/bootstrap/state.js'
-
-import { type BufferedWriter, createBufferedWriter } from './bufferedWriter.js'
-import { registerCleanup } from './cleanupRegistry.js'
-import {
-  type DebugFilter,
-  parseDebugFilter,
-  shouldShowDebugMessage,
-} from './debugFilter.js'
-import { getClaudeConfigHomeDir, isEnvTruthy } from './envUtils.js'
-import { getFsImplementation } from './fsOperations.js'
-import { writeToStderr } from './process.js'
-import { jsonStringify } from './slowOperations.js'
-
-export type DebugLogLevel = 'verbose' | 'debug' | 'info' | 'warn' | 'error'
-
-const LEVEL_ORDER: Record<DebugLogLevel, number> = {
-  verbose: 0,
-  debug: 1,
-  info: 2,
-  warn: 3,
-  error: 4,
-}
-
-/**
- * Minimum log level to include in debug output. Defaults to 'debug', which
- * filters out 'verbose' messages. Set CLAUDE_CODE_DEBUG_LOG_LEVEL=verbose to
- * include high-volume diagnostics (e.g. full statusLine command, shell, cwd,
- * stdout/stderr) that would otherwise drown out useful debug output.
- */
-export const getMinDebugLogLevel = memoize((): DebugLogLevel => {
-  const raw = process.env.CLAUDE_CODE_DEBUG_LOG_LEVEL?.toLowerCase().trim()
-  if (raw && Object.hasOwn(LEVEL_ORDER, raw)) {
-    return raw as DebugLogLevel
-  }
-  return 'debug'
-})
-
-let runtimeDebugEnabled = false
-
-export const isDebugMode = memoize((): boolean => {
-  return (
-    runtimeDebugEnabled ||
-    isEnvTruthy(process.env.DEBUG) ||
-    isEnvTruthy(process.env.DEBUG_SDK) ||
-    process.argv.includes('--debug') ||
-    process.argv.includes('-d') ||
-    isDebugToStdErr() ||
-    // Also check for --debug=pattern syntax
-    process.argv.some(arg => arg.startsWith('--debug=')) ||
-    // --debug-file implicitly enables debug mode
-    getDebugFilePath() !== null
-  )
-})
-
-/**
- * Enables debug logging mid-session (e.g. via /debug). Non-ants don't write
- * debug logs by default, so this lets them start capturing without restarting
- * with --debug. Returns true if logging was already active.
- */
-export function enableDebugLogging(): boolean {
-  const wasActive = isDebugMode() || process.env.USER_TYPE === 'ant'
-  runtimeDebugEnabled = true
-  isDebugMode.cache.clear?.()
-  return wasActive
-}
-
-// Extract and parse debug filter from command line arguments
-// Exported for testing purposes
-export const getDebugFilter = memoize((): DebugFilter | null => {
-  // Look for --debug=pattern in argv
-  const debugArg = process.argv.find(arg => arg.startsWith('--debug='))
-  if (!debugArg) {
-    return null
-  }
-
-  // Extract the pattern after the equals sign
-  const filterPattern = debugArg.substring('--debug='.length)
-  return parseDebugFilter(filterPattern)
-})
-
-export const isDebugToStdErr = memoize((): boolean => {
-  return (
-    process.argv.includes('--debug-to-stderr') || process.argv.includes('-d2e')
-  )
-})
-
-export const getDebugFilePath = memoize((): string | null => {
-  for (let i = 0; i < process.argv.length; i++) {
-    const arg = process.argv[i]!
-    if (arg.startsWith('--debug-file=')) {
-      return arg.substring('--debug-file='.length)
-    }
-    if (arg === '--debug-file' && i + 1 < process.argv.length) {
-      return process.argv[i + 1]!
-    }
-  }
-  return null
-})
-
-function shouldLogDebugMessage(message: string): boolean {
-  if (process.env.NODE_ENV === 'test' && !isDebugToStdErr()) {
-    return false
-  }
-
-  // Non-ants only write debug logs when debug mode is active (via --debug at
-  // startup or /debug mid-session). Ants always log for /share, bug reports.
-  if (process.env.USER_TYPE !== 'ant' && !isDebugMode()) {
-    return false
-  }
-
-  if (
-    typeof process === 'undefined' ||
-    typeof process.versions === 'undefined' ||
-    typeof process.versions.node === 'undefined'
-  ) {
-    return false
-  }
-
-  const filter = getDebugFilter()
-  return shouldShowDebugMessage(message, filter)
-}
-
-let hasFormattedOutput = false
-export function setHasFormattedOutput(value: boolean): void {
-  hasFormattedOutput = value
-}
-export function getHasFormattedOutput(): boolean {
-  return hasFormattedOutput
-}
-
-let debugWriter: BufferedWriter | null = null
-let pendingWrite: Promise<void> = Promise.resolve()
-
-// Module-level so .bind captures only its explicit args, not the
-// writeFn closure's parent scope (Jarred, #22257).
-async function appendAsync(
-  needMkdir: boolean,
-  dir: string,
-  path: string,
-  content: string,
-): Promise<void> {
-  if (needMkdir) {
-    await mkdir(dir, { recursive: true }).catch(() => {})
-  }
-  await appendFile(path, content)
-  void updateLatestDebugLogSymlink()
-}
-
-function noop(): void {}
-
-function getDebugWriter(): BufferedWriter {
-  if (!debugWriter) {
-    let ensuredDir: string | null = null
-    debugWriter = createBufferedWriter({
-      writeFn: content => {
-        const path = getDebugLogPath()
-        const dir = dirname(path)
-        const needMkdir = ensuredDir !== dir
-        ensuredDir = dir
-        if (isDebugMode()) {
-          // immediateMode: must stay sync. Async writes are lost on direct
-          // process.exit() and keep the event loop alive in beforeExit
-          // handlers (infinite loop with Perfetto tracing). See #22257.
-          if (needMkdir) {
-            try {
-              getFsImplementation().mkdirSync(dir)
-            } catch {
-              // Directory already exists
-            }
-          }
-          getFsImplementation().appendFileSync(path, content)
-          void updateLatestDebugLogSymlink()
-          return
-        }
-        // Buffered path (ants without --debug): flushes ~1/sec so chain
-        // depth stays ~1. .bind over a closure so only the bound args are
-        // retained, not this scope.
-        pendingWrite = pendingWrite
-          .then(appendAsync.bind(null, needMkdir, dir, path, content))
-          .catch(noop)
-      },
-      flushIntervalMs: 1000,
-      maxBufferSize: 100,
-      immediateMode: isDebugMode(),
-    })
-    registerCleanup(async () => {
-      debugWriter?.dispose()
-      await pendingWrite
-    })
-  }
-  return debugWriter
-}
-
-export async function flushDebugLogs(): Promise<void> {
-  debugWriter?.flush()
-  await pendingWrite
-}
-
-export function logForDebugging(
-  message: string,
-  { level }: { level: DebugLogLevel } = {
-    level: 'debug',
-  },
-): void {
-  if (LEVEL_ORDER[level] < LEVEL_ORDER[getMinDebugLogLevel()]) {
-    return
-  }
-  if (!shouldLogDebugMessage(message)) {
-    return
-  }
-
-  // Multiline messages break the jsonl output format, so make any multiline messages JSON.
-  if (hasFormattedOutput && message.includes('\n')) {
-    message = jsonStringify(message)
-  }
-  const timestamp = new Date().toISOString()
-  const output = `${timestamp} [${level.toUpperCase()}] ${message.trim()}\n`
-  if (isDebugToStdErr()) {
-    writeToStderr(output)
-    return
-  }
-
-  getDebugWriter().write(output)
-}
-
-export function getDebugLogPath(): string {
-  return (
-    getDebugFilePath() ??
-    process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ??
-    join(getClaudeConfigHomeDir(), 'debug', `${getSessionId()}.txt`)
-  )
-}
-
-/**
- * Updates the latest debug log symlink to point to the current debug log file.
- * Creates or updates a symlink at ~/.claude/debug/latest
- */
-const updateLatestDebugLogSymlink = memoize(async (): Promise<void> => {
-  try {
-    const debugLogPath = getDebugLogPath()
-    const debugLogsDir = dirname(debugLogPath)
-    const latestSymlinkPath = join(debugLogsDir, 'latest')
-
-    await unlink(latestSymlinkPath).catch(() => {})
-    await symlink(debugLogPath, latestSymlinkPath)
-  } catch {
-    // Silently fail if symlink creation fails
-  }
-})
-
-/**
- * Logs errors for Ants only, always visible in production.
- */
-export function logAntError(context: string, error: unknown): void {
-  if (process.env.USER_TYPE !== 'ant') {
-    return
-  }
-
-  if (error instanceof Error && error.stack) {
-    logForDebugging(`[ANT-ONLY] ${context} stack trace:\n${error.stack}`, {
-      level: 'error',
-    })
-  }
-}

package/src/utils/debugFilter.ts

@@ -1,157 +0,0 @@
-import memoize from 'lodash-es/memoize.js'
-
-export type DebugFilter = {
-  include: string[]
-  exclude: string[]
-  isExclusive: boolean
-}
-
-/**
- * Parse debug filter string into a filter configuration
- * Examples:
- * - "api,hooks" -> include only api and hooks categories
- * - "!1p,!file" -> exclude logging and file categories
- * - undefined/empty -> no filtering (show all)
- */
-export const parseDebugFilter = memoize(
-  (filterString?: string): DebugFilter | null => {
-    if (!filterString || filterString.trim() === '') {
-      return null
-    }
-
-    const filters = filterString
-      .split(',')
-      .map(f => f.trim())
-      .filter(Boolean)
-
-    // If no valid filters remain, return null
-    if (filters.length === 0) {
-      return null
-    }
-
-    // Check for mixed inclusive/exclusive filters
-    const hasExclusive = filters.some(f => f.startsWith('!'))
-    const hasInclusive = filters.some(f => !f.startsWith('!'))
-
-    if (hasExclusive && hasInclusive) {
-      // For now, we'll treat this as an error case and show all messages
-      // Log error using logForDebugging to avoid console.error lint rule
-      // We'll import and use it later when the circular dependency is resolved
-      // For now, just return null silently
-      return null
-    }
-
-    // Clean up filters (remove ! prefix) and normalize
-    const cleanFilters = filters.map(f => f.replace(/^!/, '').toLowerCase())
-
-    return {
-      include: hasExclusive ? [] : cleanFilters,
-      exclude: hasExclusive ? cleanFilters : [],
-      isExclusive: hasExclusive,
-    }
-  },
-)
-
-/**
- * Extract debug categories from a message
- * Supports multiple patterns:
- * - "category: message" -> ["category"]
- * - "[CATEGORY] message" -> ["category"]
- * - "MCP server \"name\": message" -> ["mcp", "name"]
- * - "[ANT-ONLY] 1P event: tengu_timer" -> ["ant-only", "1p"]
- *
- * Returns lowercase categories for case-insensitive matching
- */
-export function extractDebugCategories(message: string): string[] {
-  const categories: string[] = []
-
-  // Pattern 3: MCP server "servername" - Check this first to avoid false positives
-  const mcpMatch = message.match(/^MCP server ["']([^"']+)["']/)
-  if (mcpMatch && mcpMatch[1]) {
-    categories.push('mcp')
-    categories.push(mcpMatch[1].toLowerCase())
-  } else {
-    // Pattern 1: "category: message" (simple prefix) - only if not MCP pattern
-    const prefixMatch = message.match(/^([^:[]+):/)
-    if (prefixMatch && prefixMatch[1]) {
-      categories.push(prefixMatch[1].trim().toLowerCase())
-    }
-  }
-
-  // Pattern 2: [CATEGORY] at the start
-  const bracketMatch = message.match(/^\[([^\]]+)]/)
-  if (bracketMatch && bracketMatch[1]) {
-    categories.push(bracketMatch[1].trim().toLowerCase())
-  }
-
-  // Pattern 4: Check for additional categories in the message
-  // e.g., "[ANT-ONLY] 1P event: tengu_timer" should match both "ant-only" and "1p"
-  if (message.toLowerCase().includes('1p event:')) {
-    categories.push('1p')
-  }
-
-  // Pattern 5: Look for secondary categories after the first pattern
-  // e.g., "AutoUpdaterWrapper: Installation type: development"
-  const secondaryMatch = message.match(
-    /:\s*([^:]+?)(?:\s+(?:type|mode|status|event))?:/,
-  )
-  if (secondaryMatch && secondaryMatch[1]) {
-    const secondary = secondaryMatch[1].trim().toLowerCase()
-    // Only add if it's a reasonable category name (not too long, no spaces)
-    if (secondary.length < 30 && !secondary.includes(' ')) {
-      categories.push(secondary)
-    }
-  }
-
-  // If no categories found, return empty array (uncategorized)
-  return Array.from(new Set(categories)) // Remove duplicates
-}
-
-/**
- * Check if debug message should be shown based on filter
- * @param categories - Categories extracted from the message
- * @param filter - Parsed filter configuration
- * @returns true if message should be shown
- */
-export function shouldShowDebugCategories(
-  categories: string[],
-  filter: DebugFilter | null,
-): boolean {
-  // No filter means show everything
-  if (!filter) {
-    return true
-  }
-
-  // If no categories found, handle based on filter mode
-  if (categories.length === 0) {
-    // In exclusive mode, uncategorized messages are excluded by default for security
-    // In inclusive mode, uncategorized messages are excluded (must match a category)
-    return false
-  }
-
-  if (filter.isExclusive) {
-    // Exclusive mode: show if none of the categories are in the exclude list
-    return !categories.some(cat => filter.exclude.includes(cat))
-  } else {
-    // Inclusive mode: show if any of the categories are in the include list
-    return categories.some(cat => filter.include.includes(cat))
-  }
-}
-
-/**
- * Main function to check if a debug message should be shown
- * Combines extraction and filtering
- */
-export function shouldShowDebugMessage(
-  message: string,
-  filter: DebugFilter | null,
-): boolean {
-  // Fast path: no filter means show everything
-  if (!filter) {
-    return true
-  }
-
-  // Only extract categories if we have a filter
-  const categories = extractDebugCategories(message)
-  return shouldShowDebugCategories(categories, filter)
-}

package/src/utils/deepLink/banner.ts

@@ -1,123 +0,0 @@
-/**
- * Deep Link Origin Banner
- *
- * Builds the warning text shown when a session was opened by an external
- * claude-cli:// deep link. Linux xdg-open and browsers with "always allow"
- * set dispatch the link with no OS-level confirmation, so the application
- * provides its own provenance signal — mirroring claude.ai's security
- * interstitial for external-source prefills.
- *
- * The user must press Enter to submit; this banner primes them to read the
- * prompt (which may use homoglyphs or padding to hide instructions) and
- * notice which directory — and therefore which CLAUDE.md — was loaded.
- */
-
-import { stat } from 'fs/promises'
-import { homedir } from 'os'
-import { join, sep } from 'path'
-import { formatNumber, formatRelativeTimeAgo } from '../format.js'
-import { getCommonDir } from '../git/gitFilesystem.js'
-import { getGitDir } from '../git.js'
-
-const STALE_FETCH_WARN_MS = 7 * 24 * 60 * 60 * 1000
-
-/**
- * Above this length, a pre-filled prompt no longer fits on one screen
- * (~12-15 lines on an 80-col terminal). The banner switches from "review
- * carefully" to an explicit "scroll to review the entire prompt" so a
- * malicious tail buried past line 60 isn't silently off-screen.
- */
-const LONG_PREFILL_THRESHOLD = 1000
-
-export type DeepLinkBannerInfo = {
-  /** Resolved working directory the session launched in. */
-  cwd: string
-  /** Length of the ?q= prompt pre-filled in the input box. Undefined = no prefill. */
-  prefillLength?: number
-  /** The ?repo= slug if the cwd was resolved from the githubRepoPaths MRU. */
-  repo?: string
-  /** Last-fetch timestamp for the repo (FETCH_HEAD mtime). Undefined = never fetched or not a git repo. */
-  lastFetch?: Date
-}
-
-/**
- * Build the multi-line warning banner for a deep-link-originated session.
- *
- * Always shows the working directory so the user can see which CLAUDE.md
- * will load. When the link pre-filled a prompt, adds a second line prompting
- * the user to review it — the prompt itself is visible in the input box.
- *
- * When the cwd was resolved from a ?repo= slug, also shows the slug and the
- * clone's last-fetch age so the user knows which local clone was selected
- * and whether its CLAUDE.md may be stale relative to upstream.
- */
-export function buildDeepLinkBanner(info: DeepLinkBannerInfo): string {
-  const lines = [
-    `This session was opened by an external deep link in ${tildify(info.cwd)}`,
-  ]
-  if (info.repo) {
-    const age = info.lastFetch ? formatRelativeTimeAgo(info.lastFetch) : 'never'
-    const stale =
-      !info.lastFetch ||
-      Date.now() - info.lastFetch.getTime() > STALE_FETCH_WARN_MS
-    lines.push(
-      `Resolved ${info.repo} from local clones · last fetched ${age}${stale ? ' — CLAUDE.md may be stale' : ''}`,
-    )
-  }
-  if (info.prefillLength) {
-    lines.push(
-      info.prefillLength > LONG_PREFILL_THRESHOLD
-        ? `The prompt below (${formatNumber(info.prefillLength)} chars) was supplied by the link — scroll to review the entire prompt before pressing Enter.`
-        : 'The prompt below was supplied by the link — review carefully before pressing Enter.',
-    )
-  }
-  return lines.join('\n')
-}
-
-/**
- * Read the mtime of .git/FETCH_HEAD, which git updates on every fetch or
- * pull. Returns undefined if the directory is not a git repo or has never
- * been fetched.
- *
- * FETCH_HEAD is per-worktree — fetching from the main worktree does not
- * touch a sibling worktree's FETCH_HEAD. When cwd is a worktree, we check
- * both and return whichever is newer so a recently-fetched main repo
- * doesn't read as "never fetched" just because the deep link landed in
- * a worktree.
- */
-export async function readLastFetchTime(
-  cwd: string,
-): Promise<Date | undefined> {
-  const gitDir = await getGitDir(cwd)
-  if (!gitDir) return undefined
-  const commonDir = await getCommonDir(gitDir)
-  const [local, common] = await Promise.all([
-    mtimeOrUndefined(join(gitDir, 'FETCH_HEAD')),
-    commonDir
-      ? mtimeOrUndefined(join(commonDir, 'FETCH_HEAD'))
-      : Promise.resolve(undefined),
-  ])
-  if (local && common) return local > common ? local : common
-  return local ?? common
-}
-
-async function mtimeOrUndefined(p: string): Promise<Date | undefined> {
-  try {
-    const { mtime } = await stat(p)
-    return mtime
-  } catch {
-    return undefined
-  }
-}
-
-/**
- * Shorten home-dir-prefixed paths to ~ notation for the banner.
- * Not using getDisplayPath() because cwd is the current working directory,
- * so the relative-path branch would collapse it to the empty string.
- */
-function tildify(p: string): string {
-  const home = homedir()
-  if (p === home) return '~'
-  if (p.startsWith(home + sep)) return '~' + p.slice(home.length)
-  return p
-}