@take-out/cli 0.0.39

package/src/commands/run.ts

@@ -0,0 +1,173 @@
+import { spawn } from 'node:child_process'
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { resolve, join, parse } 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 ({ args, rawArgs }) => {
+    // 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()) {
+        // Check if --all flag is present
+        const hasAllFlag = secondArg === '--all'
+
+        if (hasAllFlag) {
+          // Run all scripts in this category in parallel
+          const { discoverScripts } = await import('./script')
+          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, getScriptMetadata } = await import('./script')
+        const pc = (await import('picocolors')).default
+
+        // List scripts in this category
+        const categoryScripts = discoverScripts(categoryPath)
+
+        if (categoryScripts.size > 0) {
+          console.info()
+          console.info(pc.bold(pc.cyan(`📁 ${firstArg} Scripts`)))
+          console.info()
+
+          for (const [name, path] of categoryScripts) {
+            const shortName = name.replace(`${firstArg}/`, '')
+            const metadata = getScriptMetadata(path)
+            let line = `  ${pc.green(shortName)}`
+
+            if (metadata.description) {
+              line += pc.dim(` - ${metadata.description}`)
+            }
+
+            if (metadata.args && metadata.args.length > 0) {
+              line += pc.dim(` [${metadata.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) {
+        // Run the filesystem script
+        const pc = (await import('picocolors')).default
+        console.info(pc.dim(`Running: ${normalizedName}`))
+        console.info()
+
+        // Use spawn instead of Bun's $ helper since we're in a compiled context
+        const scriptArgsToPass = scriptArgs.slice(1)
+        const child = spawn('bun', [scriptPath, ...scriptArgsToPass], {
+          stdio: 'inherit',
+          shell: false,
+        })
+
+        child.on('exit', (code) => {
+          process.exit(code || 0)
+        })
+        return
+      }
+    }
+
+    // Fall back to the original run.ts behavior for package.json scripts
+    // Find the project root by looking for package.json with workspaces or takeout field
+    let currentDir = process.cwd()
+    let projectRoot = ''
+    let hasWorkspaces = false
+
+    while (currentDir !== parse(currentDir).root) {
+      const packageJsonPath = resolve(currentDir, 'package.json')
+      if (existsSync(packageJsonPath)) {
+        try {
+          const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+          // check for workspaces (monorepo) or takeout field (ejected)
+          if (pkg.workspaces || pkg.takeout) {
+            projectRoot = currentDir
+            hasWorkspaces = Boolean(pkg.workspaces)
+            break
+          }
+        } catch {}
+      }
+      currentDir = resolve(currentDir, '..')
+    }
+
+    if (!projectRoot) {
+      console.error('Could not find project root')
+      process.exit(1)
+    }
+
+    // in monorepo mode, use local packages/scripts, otherwise use installed package
+    let scriptPath: string
+    if (hasWorkspaces) {
+      scriptPath = resolve(projectRoot, 'packages/scripts/src/run.ts')
+    } else {
+      // ejected mode - use the installed @take-out/scripts package
+      scriptPath = resolve(projectRoot, 'node_modules/@take-out/scripts/src/run.ts')
+    }
+
+    const child = spawn('bun', [scriptPath, ...scriptArgs], {
+      stdio: 'inherit',
+      shell: false,
+    })
+
+    child.on('exit', (code) => {
+      process.exit(code || 0)
+    })
+  },
+})