@o/cli 0.16.19 → 0.16.20

package/src/tko/commands/run-all.ts

@@ -0,0 +1,83 @@
+import { spawn } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve, parse } from 'node:path'
+
+import { defineCommand } from 'citty'
+
+function resolveNodeBinary(): string {
+  const explicitNode = process.env.NODE
+  if (explicitNode && existsSync(explicitNode)) {
+    return explicitNode
+  }
+
+  if (process.execPath.endsWith('/node') && existsSync(process.execPath)) {
+    return process.execPath
+  }
+
+  return 'node'
+}
+
+export const runAllCommand = defineCommand({
+  meta: {
+    name: 'run-all',
+    description: 'Run multiple package.json scripts in parallel',
+  },
+  args: {
+    scripts: {
+      type: 'positional',
+      description: 'Scripts to run in parallel',
+      required: false,
+    },
+  },
+  run: async () => {
+    const scriptArgs = process.argv.slice(3)
+    const usePty = scriptArgs.includes('--pty')
+    const filteredArgs = scriptArgs.filter((a) => a !== '--pty')
+
+    if (usePty) {
+      // pty mode still needs node + node-pty subprocess
+      const projectRoot = findProjectRoot()
+      if (!projectRoot) {
+        console.error('Could not find project root')
+        process.exit(1)
+      }
+
+      const localRunPath = resolve(projectRoot, 'packages/run/src/run-pty.mjs')
+      const scriptPath = existsSync(localRunPath)
+        ? localRunPath
+        : resolve(projectRoot, 'node_modules/@o/run/src/run-pty.mjs')
+
+      const child = spawn(resolveNodeBinary(), [scriptPath, ...filteredArgs], {
+        stdio: 'inherit',
+        shell: false,
+        env: process.env,
+      })
+
+      const code = await new Promise<number>((resolve) => {
+        child.on('exit', (code) => resolve(code || 0))
+      })
+      process.exit(code)
+    } else {
+      // direct import — no subprocess layer
+      const { runParallelScripts, parseRunArgs } = await import('@o/run')
+      await runParallelScripts(parseRunArgs(filteredArgs))
+    }
+  },
+})
+
+function findProjectRoot(): string {
+  let currentDir = process.cwd()
+  while (currentDir !== parse(currentDir).root) {
+    const packageJsonPath = resolve(currentDir, 'package.json')
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+        if (pkg.workspaces || pkg.takeout) {
+          return currentDir
+        }
+      } catch {}
+    }
+    currentDir = resolve(currentDir, '..')
+  }
+  return ''
+}

package/src/tko/commands/run.ts

@@ -0,0 +1,135 @@
+import { spawn } from 'node:child_process'
+import { existsSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { defineCommand } from 'citty'
+
+export const runCommand = defineCommand({
+  meta: {
+    name: 'run',
+    description: 'Run scripts in parallel (shorthand for "takeout script run")',
+  },
+  args: {
+    scripts: {
+      type: 'positional',
+      description: 'Scripts to run',
+      required: false,
+    },
+  },
+  run: async () => {
+    // Get all arguments after 'run'
+    const scriptArgs = process.argv.slice(3)
+    const firstArg = scriptArgs[0]
+    const secondArg = scriptArgs[1]
+
+    // Check if this is a filesystem script (category or script with slash)
+    if (firstArg) {
+      const localDir = join(process.cwd(), 'scripts')
+      const categoryPath = join(localDir, firstArg)
+
+      // Check if it's a category directory
+      if (existsSync(categoryPath) && statSync(categoryPath).isDirectory()) {
+        // only run all when flags come before any sub-script name
+        const nonFlagArgs = scriptArgs.slice(1).filter((a) => !a.startsWith('--'))
+        const hasSubScript = nonFlagArgs.length > 0
+        const hasAllFlag = secondArg === '--all' && !hasSubScript
+        const hasDefaultAllFlag = scriptArgs.includes('--default-all') && !hasSubScript
+
+        if (hasAllFlag || hasDefaultAllFlag) {
+          // Run all scripts in this category in parallel
+          const { discoverScripts } = await import('../utils/script-utils')
+          const { runScriptsInParallel } = await import('../utils/parallel-runner')
+          const pc = (await import('picocolors')).default
+          const categoryScripts = discoverScripts(categoryPath)
+
+          if (categoryScripts.size === 0) {
+            console.info(pc.yellow(`No scripts found in ${firstArg}/`))
+            return
+          }
+
+          const scriptsToRun = Array.from(categoryScripts.entries()).map(
+            ([name, path]) => ({
+              name: name.replace(`${firstArg}/`, ''),
+              path,
+            })
+          )
+
+          await runScriptsInParallel(scriptsToRun, {
+            title: pc.bold(pc.cyan(`Running all scripts in ${firstArg}/`)),
+          })
+
+          return
+        }
+
+        // Lazy load script functions only when needed
+        const { discoverScripts, getAllScriptMetadata } =
+          await import('../utils/script-utils')
+        const pc = (await import('picocolors')).default
+
+        // List scripts in this category
+        const categoryScripts = discoverScripts(categoryPath)
+
+        if (categoryScripts.size > 0) {
+          const metadata = await getAllScriptMetadata(categoryScripts)
+
+          console.info()
+          console.info(pc.bold(pc.cyan(`${firstArg} Scripts`)))
+          console.info()
+
+          for (const [name] of categoryScripts) {
+            const shortName = name.replace(`${firstArg}/`, '')
+            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 ${firstArg} <name> [args...]`))
+          console.info(pc.dim(`Or:  tko ${firstArg} --all to run all scripts`))
+          console.info(pc.dim(`Or:  tko run ${firstArg}/<name> [args...] to execute`))
+          console.info()
+        } else {
+          const pc = (await import('picocolors')).default
+          console.info(pc.yellow(`No scripts found in ${firstArg}/`))
+        }
+        return
+      }
+
+      // Check if it's a direct script reference (with slash or colon)
+      const normalizedName = firstArg.replace(/:/g, '/')
+
+      // Lazy load findScript only when needed
+      const { findScript } = await import('./script')
+      const scriptPath = findScript(normalizedName)
+
+      if (scriptPath) {
+        // Use spawn instead of Bun's $ helper since we're in a compiled context
+        const scriptArgsToPass = scriptArgs
+          .slice(1)
+          .filter((a) => a !== '--default-all' && a !== '--all')
+        const child = spawn('bun', [scriptPath, ...scriptArgsToPass], {
+          stdio: 'inherit',
+          shell: false,
+        })
+
+        const code = await new Promise<number>((resolve) => {
+          child.on('exit', (code) => resolve(code || 0))
+        })
+        process.exit(code)
+      }
+    }
+
+    // fall back to runParallelScripts for package.json scripts (direct import, no subprocess)
+    const { runParallelScripts, parseRunArgs } = await import('@o/run')
+    await runParallelScripts(parseRunArgs(scriptArgs))
+  },
+})

package/src/tko/commands/script.ts

@@ -0,0 +1,431 @@
+/**
+ * Enhanced Script command - hybrid script runner with filesystem discovery
+ */
+
+import {
+  existsSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+  mkdirSync,
+} from 'node:fs'
+import { join, relative, dirname, basename } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { defineCommand } from 'citty'
+import pc from 'picocolors'
+
+import { listAllScripts, listCategoryScripts } from '../utils/script-listing'
+import { getLocalScriptsDir } from '../utils/script-utils'
+import {
+  type FileToSync,
+  compareFiles,
+  getFileSize,
+  syncFileWithConfirmation,
+} from '../utils/sync'
+
+// find scripts package root using import.meta.resolve
+function findScriptsPackageRoot(): string | null {
+  try {
+    const resolved = import.meta.resolve('@o/scripts/package.json')
+    // use fileURLToPath for proper cross-platform handling
+    const packageJsonPath = fileURLToPath(new URL(resolved))
+    const packageRoot = join(packageJsonPath, '..')
+    const srcPath = join(packageRoot, 'src')
+
+    if (existsSync(srcPath)) {
+      return srcPath
+    }
+  } catch (err) {
+    // scripts package not found, that's ok for hybrid mode
+  }
+
+  return null
+}
+
+// find a script by name (checks both built-in and local)
+export function findScript(name: string): string | null {
+  // normalize name: convert colons to slashes for consistency
+  const normalizedName = name.replace(/:/g, '/')
+
+  // 1. check local scripts first (they override built-ins)
+  const localDir = getLocalScriptsDir()
+
+  // try direct file path with normalized name
+  for (const ext of ['.ts', '.js', '']) {
+    const localPath = join(localDir, `${normalizedName}${ext}`)
+    if (existsSync(localPath)) {
+      return localPath
+    }
+  }
+
+  // 2. check built-in scripts
+  const builtInDir = findScriptsPackageRoot()
+  if (builtInDir) {
+    for (const ext of ['.ts', '.js', '']) {
+      const builtInPath = join(builtInDir, `${normalizedName}${ext}`)
+      if (existsSync(builtInPath)) {
+        return builtInPath
+      }
+    }
+  }
+
+  return null
+}
+
+export { listAllScripts, listCategoryScripts } from '../utils/script-listing'
+
+// run a script
+async function runScript(scriptPath: string, args: string[]): Promise<void> {
+  console.info(pc.dim(`Running: ${relative(process.cwd(), scriptPath)}`))
+  console.info()
+
+  try {
+    const { $ } = await import('bun')
+    await $`bun ${scriptPath} ${args}`
+  } catch (err) {
+    console.error(pc.red(`✗ Error running script: ${err}`))
+    process.exit(1)
+  }
+}
+
+// new command for creating scripts
+const newCommand = defineCommand({
+  meta: {
+    name: 'new',
+    description: 'Create a new script from template',
+  },
+  args: {
+    path: {
+      type: 'positional',
+      description: 'Path for the new script (e.g., ci/test)',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    const scriptPath = args.path
+    const localDir = getLocalScriptsDir()
+
+    // determine full path
+    const fullPath = join(localDir, `${scriptPath}.ts`)
+    const dir = dirname(fullPath)
+
+    // create directory if needed
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+
+    // check if file exists
+    if (existsSync(fullPath)) {
+      console.error(
+        pc.red(`✗ Script already exists: ${relative(process.cwd(), fullPath)}`)
+      )
+      process.exit(1)
+    }
+
+    // create template
+    const template = `#!/usr/bin/env bun
+
+/**
+ * @description TODO: Add description
+ * @args --verbose, --dry-run
+ */
+
+import { args } from '@o/scripts/helpers/args'
+
+const { verbose, dryRun } = args('--verbose boolean --dry-run boolean')
+
+async function main() {
+  console.info('Running ${basename(scriptPath)}...')
+
+  if (verbose) {
+    console.info('Verbose mode enabled')
+  }
+
+  if (dryRun) {
+    console.info('Dry run mode - no changes will be made')
+  }
+
+  // TODO: Implement your script logic here
+}
+
+main().catch(console.error)
+`
+
+    writeFileSync(fullPath, template)
+    console.info(pc.green(`✓ Created new script: ${relative(process.cwd(), fullPath)}`))
+    console.info()
+    console.info(pc.dim(`Edit the script and update the TODO sections`))
+  },
+})
+
+// get all script files recursively
+function getAllScriptFiles(dir: string, baseDir: string = dir): string[] {
+  const files: string[] = []
+
+  if (!existsSync(dir)) {
+    return files
+  }
+
+  try {
+    const entries = readdirSync(dir)
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry)
+      const stat = statSync(fullPath)
+
+      if (stat.isDirectory()) {
+        files.push(...getAllScriptFiles(fullPath, baseDir))
+      } else if (
+        entry.endsWith('.ts') ||
+        entry.endsWith('.js') ||
+        entry.endsWith('.cjs')
+      ) {
+        // normalize to forward slashes for consistent naming
+        files.push(relative(baseDir, fullPath).split('\\').join('/'))
+      }
+    }
+  } catch (err) {
+    // ignore directory read errors
+  }
+
+  return files
+}
+
+// eject command to copy built-in scripts to local directory
+const ejectCommand = defineCommand({
+  meta: {
+    name: 'eject',
+    description: 'Eject built-in scripts into your project',
+  },
+  args: {
+    yes: {
+      type: 'boolean',
+      description: 'Skip confirmations and eject all files',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const cwd = process.cwd()
+    const targetScriptsDir = join(cwd, 'scripts')
+    const sourceScriptsDir = findScriptsPackageRoot()
+
+    console.info()
+    console.info(pc.bold(pc.cyan('⚙️  Eject Scripts')))
+    console.info()
+
+    if (!sourceScriptsDir) {
+      console.error(
+        pc.red('✗ Built-in scripts package (@o/scripts) not found or not installed')
+      )
+      console.info()
+      console.info(pc.dim('Install with: bun add -d @o/scripts'))
+      process.exit(1)
+    }
+
+    console.info(pc.dim(`Source: ${sourceScriptsDir}`))
+    console.info(pc.dim(`Target: ${targetScriptsDir}`))
+    console.info()
+
+    // ensure target scripts directory exists
+    if (!existsSync(targetScriptsDir)) {
+      console.info(pc.yellow('⚠ Target scripts directory does not exist, will create it'))
+      mkdirSync(targetScriptsDir, { recursive: true })
+    }
+
+    // get all script files from source (including subdirectories)
+    const sourceFiles = getAllScriptFiles(sourceScriptsDir)
+
+    if (sourceFiles.length === 0) {
+      console.info(pc.yellow('No script files found in built-in scripts package'))
+      return
+    }
+
+    // analyze all files
+    const filesToSync: FileToSync[] = []
+    const stats = {
+      new: 0,
+      modified: 0,
+      identical: 0,
+    }
+
+    for (const file of sourceFiles) {
+      const sourcePath = join(sourceScriptsDir, file)
+      const targetPath = join(targetScriptsDir, file)
+      const status = compareFiles(sourcePath, targetPath)
+
+      stats[status]++
+
+      filesToSync.push({
+        name: file,
+        sourcePath,
+        targetPath,
+        status,
+        sourceSize: getFileSize(sourcePath),
+        targetSize: getFileSize(targetPath),
+      })
+    }
+
+    console.info(pc.bold('Summary:'))
+    console.info(`  ${pc.green(`${stats.new} new`)}`)
+    console.info(`  ${pc.yellow(`${stats.modified} modified`)}`)
+    console.info(`  ${pc.dim(`${stats.identical} identical`)}`)
+    console.info()
+
+    if (stats.new === 0 && stats.modified === 0) {
+      console.info(pc.green('✓ All scripts are already up to date!'))
+      return
+    }
+
+    // sort files: new first, then modified, then identical
+    const sortOrder = { new: 0, modified: 1, identical: 2 }
+    filesToSync.sort((a, b) => sortOrder[a.status] - sortOrder[b.status])
+
+    // sync files
+    let syncedCount = 0
+
+    for (const file of filesToSync) {
+      if (args.yes && file.status !== 'identical') {
+        // auto-sync without confirmation
+        const targetDir = dirname(file.targetPath)
+        if (!existsSync(targetDir)) {
+          mkdirSync(targetDir, { recursive: true })
+        }
+        const content = readFileSync(file.sourcePath)
+        writeFileSync(file.targetPath, content)
+        console.info(pc.green(`  ✓ ${file.name}`))
+        syncedCount++
+      } else {
+        const wasSynced = await syncFileWithConfirmation(file)
+        if (wasSynced) {
+          syncedCount++
+        }
+      }
+    }
+
+    console.info()
+    console.info(pc.bold(pc.green(`✓ Complete: ${syncedCount} file(s) ejected`)))
+    console.info()
+  },
+})
+
+// run subcommand for backwards compatibility
+const runSubCommand = defineCommand({
+  meta: {
+    name: 'run',
+    description: 'Run a script (for backwards compatibility)',
+  },
+  args: {
+    name: {
+      type: 'positional',
+      description: 'Script name',
+      required: true,
+    },
+  },
+  async run({ args, rawArgs }) {
+    // Find and run the script
+    const scriptPath = findScript(args.name)
+
+    if (!scriptPath) {
+      console.error(pc.red(`✗ Script not found: ${args.name}`))
+      console.info()
+      console.info(pc.dim(`Run 'tko script' to see available scripts`))
+      process.exit(1)
+    }
+
+    // Extract args after the script name
+    const scriptArgs = rawArgs.slice(rawArgs.indexOf(args.name) + 1)
+
+    await runScript(scriptPath, scriptArgs)
+  },
+})
+
+// main script command (handles both list and run)
+export const scriptCommand = defineCommand({
+  meta: {
+    name: 'script',
+    description: 'Hybrid script runner with filesystem discovery',
+  },
+  args: {
+    name: {
+      type: 'positional',
+      description: 'Script name or category to run/list',
+      required: false,
+    },
+  },
+  subCommands: {
+    new: newCommand,
+    run: runSubCommand,
+    eject: ejectCommand,
+  },
+  async run({ args, rawArgs }) {
+    // citty doesn't handle args with hyphens well, so use rawArgs directly
+    // rawArgs[0] is 'script', rawArgs[1] is the actual script name
+    const scriptName = args.name || rawArgs[1]
+
+    // if no name provided, list all available scripts
+    if (!scriptName) {
+      await listAllScripts(false)
+      return
+    }
+
+    // check if this is a category listing
+    if (await listCategoryScripts(scriptName)) {
+      return
+    }
+
+    // find and run the script
+    const scriptPath = findScript(scriptName)
+
+    if (!scriptPath) {
+      console.error(pc.red(`✗ Script not found: ${scriptName}`))
+      console.info()
+      console.info(pc.dim(`Run 'tko script' to see available scripts`))
+      process.exit(1)
+    }
+
+    // extract args after the script name
+    const scriptArgs = rawArgs.slice(rawArgs.indexOf(scriptName) + 1)
+
+    await runScript(scriptPath, scriptArgs)
+  },
+})
+
+// shorthand command that skips "script" subcommand
+export function createShorthandCommand(name: string) {
+  return defineCommand({
+    meta: {
+      name,
+      description: 'Run script directly',
+    },
+    args: {
+      args: {
+        type: 'positional',
+        description: 'Script and arguments',
+        required: false,
+      },
+    },
+    async run({ rawArgs }) {
+      // if no args provided, list scripts in this category
+      const scriptName = rawArgs.length > 0 ? `${name}/${rawArgs[0]}` : name
+      const scriptArgs =
+        rawArgs.length > 0
+          ? ['script', scriptName, ...rawArgs.slice(1)]
+          : ['script', name]
+
+      // delegate to script command
+      const { run } = scriptCommand
+      if (run) {
+        await run({
+          args: {
+            name: scriptName,
+            _: rawArgs.slice(1),
+          },
+          rawArgs: scriptArgs,
+          cmd: scriptCommand,
+        })
+      }
+    },
+  })
+}