@o/cli 0.16.19 → 0.16.20

package/src/tko/utils/prompts.ts

@@ -0,0 +1,203 @@
+/**
+ * Reusable prompt helpers using @clack/prompts
+ */
+
+import * as p from '@clack/prompts'
+import pc from 'picocolors'
+
+import type { PortCheck, PrerequisiteCheck } from '../types'
+
+export function displayWelcome(projectName = 'Takeout'): void {
+  console.info()
+  p.intro(pc.bgCyan(pc.black(` ${projectName} Starter Kit `)))
+  console.info()
+  p.note(
+    pc.dim(
+      "You can re-run 'bun onboard' anytime to reconfigure or skip to specific steps.\nNo need to decide everything upfront!"
+    ),
+    pc.cyan('Tip')
+  )
+}
+
+export function displayOutro(message: string): void {
+  p.outro(pc.green(message))
+}
+
+export function displayPrerequisites(checks: PrerequisiteCheck[]): void {
+  const items = checks.map((check) => {
+    const icon = check.installed ? pc.green('✓') : pc.red('✗')
+    const message = check.message || ''
+    const recommendation = check.recommendation
+      ? `\n    ${pc.dim(check.recommendation)}`
+      : ''
+    return `${icon} ${pc.bold(check.name)}: ${message}${recommendation}`
+  })
+
+  p.note(items.join('\n'), 'Prerequisites')
+}
+
+export function displayPortConflicts(conflicts: PortCheck[]): void {
+  if (conflicts.length === 0) return
+
+  const items = conflicts.map((conflict) => {
+    const pid = conflict.pid ? ` (PID: ${conflict.pid})` : ''
+    return `${pc.yellow('⚠')} Port ${conflict.port} (${conflict.name})${pid}`
+  })
+
+  p.note(items.join('\n'), pc.yellow('Port Conflicts Detected'))
+}
+
+export async function confirmContinue(
+  message: string,
+  defaultValue = true
+): Promise<boolean> {
+  const result = await p.confirm({
+    message,
+    initialValue: defaultValue,
+  })
+
+  if (p.isCancel(result)) {
+    p.cancel('Operation cancelled.')
+    process.exit(0)
+  }
+
+  return result
+}
+
+export async function promptText(
+  message: string,
+  defaultValue?: string,
+  placeholder?: string
+): Promise<string> {
+  const result = await p.text({
+    message,
+    defaultValue,
+    placeholder,
+  })
+
+  if (p.isCancel(result)) {
+    p.cancel('Operation cancelled.')
+    process.exit(0)
+  }
+
+  return result
+}
+
+export async function promptPassword(message: string): Promise<string> {
+  const result = await p.password({
+    message,
+  })
+
+  if (p.isCancel(result)) {
+    p.cancel('Operation cancelled.')
+    process.exit(0)
+  }
+
+  return result
+}
+
+export async function promptSelect<T extends string>(
+  message: string,
+  options: { value: T; label: string; hint?: string }[]
+): Promise<T | 'cancel'> {
+  const result = await p.select({
+    message,
+    options: options as any,
+  })
+
+  if (p.isCancel(result)) {
+    return 'cancel' as const
+  }
+
+  return result as T
+}
+
+export async function promptStartStep(
+  hasLocalPackages = true
+): Promise<
+  'full' | 'prerequisites' | 'identity' | 'ports' | 'eject' | 'production' | 'cancel'
+> {
+  console.info()
+  console.info(pc.gray('What would you like to do?'))
+  console.info()
+
+  return promptSelect('Select starting point:', [
+    {
+      value: 'full',
+      label: 'Complete setup',
+      hint: 'Run through all setup steps',
+    },
+    {
+      value: 'prerequisites',
+      label: 'Check prerequisites',
+      hint: 'Verify bun, docker, git, etc.',
+    },
+    {
+      value: 'identity',
+      label: 'Project identity',
+      hint: 'Customize app name and bundle ID',
+    },
+    {
+      value: 'ports',
+      label: 'Check ports',
+      hint: 'Verify required ports are available',
+    },
+    ...(hasLocalPackages
+      ? [
+          {
+            value: 'eject' as const,
+            label: 'Eject from monorepo',
+            hint: 'Remove ./packages, use published versions',
+          },
+        ]
+      : []),
+    {
+      value: 'production',
+      label: 'Production deployment',
+      hint: 'Configure production environment and deployment',
+    },
+  ])
+}
+
+export async function promptOldSelect<T extends string>(
+  message: string,
+  options: { value: T; label: string; hint?: string }[]
+): Promise<T> {
+  const result = await p.select<string>({
+    message,
+    options,
+  })
+
+  if (p.isCancel(result)) {
+    p.cancel('Operation cancelled.')
+    process.exit(0)
+  }
+
+  return result as T
+}
+
+export function showSpinner(message: string): ReturnType<typeof p.spinner> {
+  const s = p.spinner()
+  s.start(message)
+  return s
+}
+
+export function showError(message: string): void {
+  p.log.error(pc.red(message))
+}
+
+export function showWarning(message: string): void {
+  p.log.warning(pc.yellow(message))
+}
+
+export function showSuccess(message: string): void {
+  p.log.success(pc.green(message))
+}
+
+export function showInfo(message: string): void {
+  p.log.info(pc.blue(message))
+}
+
+export function showStep(message: string): void {
+  p.log.step(message)
+}

package/src/tko/utils/script-listing.ts

@@ -0,0 +1,194 @@
+/**
+ * Utility functions for listing and discovering scripts
+ */
+
+import { existsSync, statSync } from 'node:fs'
+import { join, relative } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import pc from 'picocolors'
+
+import {
+  type ScriptMetadata,
+  discoverScripts,
+  getAllScriptMetadata,
+  getLocalScriptsDir,
+} from './script-utils'
+
+// find scripts package root using import.meta.resolve
+function findScriptsPackageRoot(): string | null {
+  try {
+    const resolved = import.meta.resolve('@o/scripts/package.json')
+    const packageJsonPath = fileURLToPath(new URL(resolved))
+    const packageRoot = join(packageJsonPath, '..')
+    const srcPath = join(packageRoot, 'src')
+
+    if (existsSync(srcPath)) {
+      return srcPath
+    }
+  } catch {
+    // scripts package not found
+  }
+
+  return null
+}
+
+// format script listing with pre-fetched metadata
+function formatScriptList(
+  title: string,
+  scripts: Map<string, string>,
+  metadata: Map<string, ScriptMetadata>
+): void {
+  if (scripts.size === 0) return
+
+  console.info()
+  console.info(pc.bold(pc.cyan(title)))
+  console.info()
+
+  const categories = new Map<string, Array<[string, string]>>()
+  const rootScripts: Array<[string, string]> = []
+
+  for (const [name, path] of scripts) {
+    if (name.includes('/')) {
+      const category = name.split('/')[0]!
+      if (!categories.has(category)) {
+        categories.set(category, [])
+      }
+      categories.get(category)!.push([name, path])
+    } else {
+      rootScripts.push([name, path])
+    }
+  }
+
+  for (const [name] of rootScripts) {
+    let line = `  ${pc.green(name)}`
+    const meta = metadata.get(name)
+    if (meta?.description) {
+      line += pc.dim(` - ${meta.description}`)
+    }
+    console.info(line)
+  }
+
+  for (const [category, categoryScripts] of categories) {
+    console.info()
+    console.info(`  ${pc.yellow(category)}/`)
+
+    for (const [name] of categoryScripts) {
+      const shortName = name.substring(category.length + 1)
+      let line = `    ${pc.green(shortName)}`
+      const meta = metadata.get(name)
+      if (meta?.description) {
+        line += pc.dim(` - ${meta.description}`)
+      }
+      console.info(line)
+    }
+  }
+}
+
+// list all available scripts
+export async function listAllScripts(includeCommands = true) {
+  console.info()
+  console.info(pc.bold(pc.cyan('Takeout CLI - Project Scripts & Commands')))
+  console.info()
+  console.info(pc.dim('  Manage scripts, run tasks, and configure your project'))
+  console.info()
+
+  if (includeCommands) {
+    console.info(pc.bold(pc.cyan('Built-in Commands')))
+    console.info()
+    console.info(`  ${pc.green('onboard')} - Setup wizard for new projects`)
+    console.info(`  ${pc.green('docs')} - View documentation`)
+    console.info(`  ${pc.green('env:setup')} - Setup environment variables`)
+    console.info(`  ${pc.green('run')} - Run scripts in parallel`)
+    console.info(`  ${pc.green('script')} - Manage and run scripts`)
+    console.info(`  ${pc.green('skills')} - Manage Claude Code skills`)
+    console.info(`  ${pc.green('sync')} - Sync fork with upstream Takeout`)
+    console.info(`  ${pc.green('changed')} - Show changes since last sync`)
+    console.info(`  ${pc.green('completion')} - Shell completion setup`)
+  }
+
+  const localScripts = discoverScripts(getLocalScriptsDir())
+  const builtInDir = findScriptsPackageRoot()
+  const builtInScripts = builtInDir ? discoverScripts(builtInDir) : new Map()
+
+  const allScripts = new Map([...localScripts, ...builtInScripts])
+  const metadata = await getAllScriptMetadata(allScripts)
+
+  if (localScripts.size > 0) {
+    formatScriptList('Local Scripts', localScripts, metadata)
+  }
+
+  if (builtInScripts.size > 0) {
+    formatScriptList('Built-in Scripts', builtInScripts, metadata)
+  }
+
+  if (localScripts.size === 0 && builtInScripts.size === 0) {
+    console.info()
+    console.info(pc.yellow('No scripts found'))
+    console.info()
+    console.info(
+      pc.dim(`Create scripts in ${relative(process.cwd(), getLocalScriptsDir())}/`)
+    )
+    console.info(pc.dim(`Or install @o/scripts package for built-in scripts`))
+  }
+
+  console.info()
+  console.info(pc.bold('Usage:'))
+  console.info(
+    `  ${pc.cyan('tko <command>')}           ${pc.dim('Run a built-in command')}`
+  )
+  console.info(
+    `  ${pc.cyan('tko <script-name>')}       ${pc.dim('Execute direct script')}`
+  )
+  console.info(
+    `  ${pc.cyan('tko <group> <script>')}    ${pc.dim('Execute nested script')}`
+  )
+  console.info(`  ${pc.cyan('tko script new <path>')}   ${pc.dim('Create a new script')}`)
+  console.info()
+}
+
+// check if a name is a category and list its scripts
+export async function listCategoryScripts(categoryName: string): Promise<boolean> {
+  const localDir = getLocalScriptsDir()
+  const categoryPath = join(localDir, categoryName)
+
+  if (existsSync(categoryPath) && statSync(categoryPath).isDirectory()) {
+    const categoryScripts = discoverScripts(categoryPath)
+
+    if (categoryScripts.size > 0) {
+      const metadata = await getAllScriptMetadata(categoryScripts)
+
+      console.info()
+      console.info(pc.bold(pc.cyan(`${categoryName} Scripts`)))
+      console.info()
+
+      for (const [name] of categoryScripts) {
+        const shortName = name.replace(`${categoryName}/`, '')
+        const meta = metadata.get(name)
+        let line = `  ${pc.green(shortName)}`
+
+        if (meta?.description) {
+          line += pc.dim(` - ${meta.description}`)
+        }
+
+        if (meta?.args && meta.args.length > 0) {
+          line += pc.dim(` [${meta.args.join(', ')}]`)
+        }
+
+        console.info(line)
+      }
+
+      console.info()
+      console.info(pc.dim(`Run: tko ${categoryName}/<name> [args...] to execute`))
+      console.info()
+    } else {
+      console.info()
+      console.info(pc.yellow(`No scripts found in ${categoryName}/`))
+      console.info()
+    }
+
+    return true
+  }
+
+  return false
+}

package/src/tko/utils/script-utils.ts

@@ -0,0 +1,103 @@
+/**
+ * Core utility functions for script discovery and metadata
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { join, relative } from 'node:path'
+
+import { setInterceptCmd } from '@o/scripts/cmd'
+
+export interface ScriptMetadata {
+  description?: string
+  args?: string[]
+}
+
+// get local scripts directory
+export function getLocalScriptsDir(): string {
+  return join(process.cwd(), 'scripts')
+}
+
+// batch extract metadata for all scripts via import interception
+export async function getAllScriptMetadata(
+  scripts: Map<string, string>
+): Promise<Map<string, ScriptMetadata>> {
+  const collected = new Map<string, { description: string; args?: string }>()
+  let currentName = ''
+
+  // interceptor stays set — never cleared so floating .run() promises always bail
+  setInterceptCmd((info) => {
+    collected.set(currentName, info)
+  })
+
+  for (const [name, path] of scripts) {
+    // only import scripts that use cmd (safe to import)
+    try {
+      const head = readFileSync(path, 'utf-8').slice(0, 200)
+      if (!head.includes('cmd')) continue
+    } catch {
+      continue
+    }
+
+    currentName = name
+    try {
+      await import(path)
+    } catch {}
+  }
+
+  const results = new Map<string, ScriptMetadata>()
+  for (const [name, info] of collected) {
+    const metadata: ScriptMetadata = { description: info.description }
+    if (info.args) {
+      const flags = [...info.args.matchAll(/--?([a-z-]+)/gi)]
+      if (flags.length > 0) {
+        metadata.args = flags.map((m) => `--${m[1]}`)
+      }
+    }
+    results.set(name, metadata)
+  }
+
+  return results
+}
+
+// discover scripts in a directory (no grandchildren)
+export function discoverScripts(dir: string, baseDir: string = dir): Map<string, string> {
+  const scripts = new Map<string, string>()
+
+  if (!existsSync(dir)) {
+    return scripts
+  }
+
+  try {
+    const entries = readdirSync(dir)
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry)
+      const stat = statSync(fullPath)
+
+      if (stat.isDirectory()) {
+        if (entry === 'helpers' || entry === 'internal') continue
+        // one level deep only
+        const subEntries = readdirSync(fullPath)
+        for (const subEntry of subEntries) {
+          const subPath = join(fullPath, subEntry)
+          if (
+            statSync(subPath).isFile() &&
+            (subEntry.endsWith('.ts') || subEntry.endsWith('.js'))
+          ) {
+            const relativePath = relative(baseDir, subPath).split('\\').join('/')
+            const scriptName = relativePath.replace(/\.(ts|js)$/, '')
+            scripts.set(scriptName, subPath)
+          }
+        }
+      } else if (entry.endsWith('.ts') || entry.endsWith('.js')) {
+        const relativePath = relative(baseDir, fullPath).split('\\').join('/')
+        const scriptName = relativePath.replace(/\.(ts|js)$/, '')
+        scripts.set(scriptName, fullPath)
+      }
+    }
+  } catch {
+    // ignore directory read errors
+  }
+
+  return scripts
+}

package/src/tko/utils/sync.ts

@@ -0,0 +1,101 @@
+/**
+ * Sync utilities for updating docs and scripts between repositories
+ */
+
+import { createHash } from 'node:crypto'
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'node:fs'
+import { join, relative, dirname } from 'node:path'
+
+import { confirm } from '@clack/prompts'
+import pc from 'picocolors'
+
+export interface FileToSync {
+  name: string
+  sourcePath: string
+  targetPath: string
+  status: 'new' | 'modified' | 'identical'
+  sourceSize?: number
+  targetSize?: number
+}
+
+export function getFileHash(filePath: string): string {
+  const content = readFileSync(filePath)
+  return createHash('md5').update(content).digest('hex')
+}
+
+export function compareFiles(
+  sourcePath: string,
+  targetPath: string
+): 'new' | 'modified' | 'identical' {
+  if (!existsSync(targetPath)) {
+    return 'new'
+  }
+
+  const sourceHash = getFileHash(sourcePath)
+  const targetHash = getFileHash(targetPath)
+
+  return sourceHash === targetHash ? 'identical' : 'modified'
+}
+
+export async function syncFileWithConfirmation(file: FileToSync): Promise<boolean> {
+  const relPath = relative(process.cwd(), file.targetPath)
+
+  if (file.status === 'identical') {
+    console.info(pc.dim(`  ✓ ${file.name} (already up to date)`))
+    return false
+  }
+
+  const statusColor = file.status === 'new' ? pc.green : pc.yellow
+  const statusText = file.status === 'new' ? 'NEW' : 'MODIFIED'
+
+  console.info()
+  console.info(statusColor(`  ${statusText}: ${file.name}`))
+
+  if (file.status === 'modified') {
+    const sourceSize = file.sourceSize || 0
+    const targetSize = file.targetSize || 0
+    const diff = sourceSize - targetSize
+
+    console.info(pc.dim(`    Source: ${sourceSize} bytes`))
+    console.info(pc.dim(`    Target: ${targetSize} bytes`))
+
+    if (diff > 0) {
+      console.info(pc.cyan(`    Source is ${diff} bytes larger`))
+    } else if (diff < 0) {
+      console.info(pc.magenta(`    Target is ${Math.abs(diff)} bytes larger`))
+    }
+  }
+
+  console.info(pc.dim(`    → ${relPath}`))
+
+  const shouldSync = await confirm({
+    message: `Overwrite this file?`,
+    initialValue: true,
+  })
+
+  if (shouldSync === false || typeof shouldSync === 'symbol') {
+    console.info(pc.dim(`  ⊘ Skipped`))
+    return false
+  }
+
+  // ensure target directory exists
+  const targetDir = dirname(file.targetPath)
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true })
+  }
+
+  // copy file
+  const content = readFileSync(file.sourcePath)
+  writeFileSync(file.targetPath, content)
+
+  console.info(pc.green(`  ✓ Synced`))
+  return true
+}
+
+export function getFileSize(filePath: string): number {
+  try {
+    return statSync(filePath).size
+  } catch {
+    return 0
+  }
+}

package/src/tko/withExpoModulesCoreSwift6Fix.cjs

@@ -0,0 +1,58 @@
+const { withDangerousMod } = require('@expo/config-plugins')
+const fs = require('node:fs')
+const path = require('node:path')
+
+/**
+ * expo config plugin to fix expo-modules-core 55.x swift 6 strict concurrency errors
+ * that break TurboModule registration (PlatformConstants not found)
+ * adapted from tamagui/kitchen-sink
+ * see: https://github.com/expo/expo/issues/42525
+ */
+function withExpoModulesCoreSwift6Fix(config) {
+  return withDangerousMod(config, [
+    'ios',
+    async (config) => {
+      const podfilePath = path.join(config.modRequest.platformProjectRoot, 'Podfile')
+
+      if (!fs.existsSync(podfilePath)) {
+        return config
+      }
+
+      let podfile = fs.readFileSync(podfilePath, 'utf8')
+
+      if (podfile.includes('# workaround: expo-modules-core 55.x')) {
+        return config
+      }
+
+      const workaround = `
+    # workaround: expo-modules-core 55.x requires Swift 6 mode with isolated
+    # conformances (SE-0470) for @MainActor in protocol conformance syntax.
+    # SWIFT_STRICT_CONCURRENCY=minimal suppresses concurrency warnings/errors.
+    installer.pods_project.targets.each do |target|
+      if target.name == 'ExpoModulesCore'
+        target.build_configurations.each do |build_config|
+          build_config.build_settings['SWIFT_VERSION'] = '6'
+          build_config.build_settings['SWIFT_STRICT_CONCURRENCY'] = 'minimal'
+          flags = build_config.build_settings['OTHER_SWIFT_FLAGS'] || '$(inherited)'
+          unless flags.include?('IsolatedConformances')
+            build_config.build_settings['OTHER_SWIFT_FLAGS'] = "#{flags} -enable-upcoming-feature IsolatedConformances"
+          end
+        end
+      end
+    end
+`
+      const updated = podfile.replace(
+        /(post_install do \|installer\|.*?)(^\s+end\s*\nend)/ms,
+        `$1${workaround}$2`
+      )
+
+      if (updated !== podfile) {
+        fs.writeFileSync(podfilePath, updated)
+      }
+
+      return config
+    },
+  ])
+}
+
+module.exports = withExpoModulesCoreSwift6Fix

package/src/tko/withOpSqliteStatic.cjs

@@ -0,0 +1,51 @@
+const { withDangerousMod } = require('@expo/config-plugins')
+const { mergeContents } = require('@expo/config-plugins/build/utils/generateCode')
+const fs = require('node:fs')
+const path = require('node:path')
+
+/**
+ * expo config plugin to add pre_install hook for op-sqlite static framework compilation
+ * required when using useFrameworks: 'static'
+ * based on: https://github.com/OP-Engineering/op-sqlite/issues/238
+ */
+function withOpSqliteStatic(config) {
+  return withDangerousMod(config, [
+    'ios',
+    async (config) => {
+      const podfilePath = path.join(config.modRequest.platformProjectRoot, 'Podfile')
+
+      if (!fs.existsSync(podfilePath)) {
+        return config
+      }
+
+      const podfileContent = fs.readFileSync(podfilePath, 'utf-8')
+
+      const setOpSqliteStatic = mergeContents({
+        tag: 'op-sqlite-static-library',
+        src: podfileContent,
+        newSrc: `pre_install do |installer|
+  installer.pod_targets.each do |pod|
+    if pod.name.eql?('op-sqlite')
+      def pod.build_type
+        Pod::BuildType.static_library
+      end
+    end
+  end
+end`,
+        anchor: /platform :ios.*/,
+        offset: 1,
+        comment: '#',
+      })
+
+      if (!setOpSqliteStatic.didMerge) {
+        return config
+      }
+
+      fs.writeFileSync(podfilePath, setOpSqliteStatic.contents)
+
+      return config
+    },
+  ])
+}
+
+module.exports = withOpSqliteStatic