@take-out/cli 0.0.93 → 0.0.94

package/src/cli.ts

@@ -1,10 +1,11 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 /**
  * Takeout CLI
  * Interactive tools for Takeout starter kit setup and management
  */
 
+import { spawnSync } from 'node:child_process'
 import { existsSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 
@@ -22,23 +23,27 @@ function isScriptCategory(name: string): boolean {
   }
 }
 
-// check if a name is a local script in ./scripts/
-function isLocalScript(name: string): boolean {
+// find a local script in ./scripts/, returns path or null
+function findLocalScript(name: string): string | null {
   const scriptsDir = join(process.cwd(), 'scripts')
   const normalizedName = name.replace(/:/g, '/')
 
   for (const ext of ['.ts', '.js', '']) {
     const scriptPath = join(scriptsDir, `${normalizedName}${ext}`)
     if (existsSync(scriptPath)) {
-      return true
+      return scriptPath
     }
   }
 
-  return false
+  return null
 }
 
-// check if a name could be a built-in script
-function isBuiltInScript(name: string): boolean {
+function isLocalScript(name: string): boolean {
+  return findLocalScript(name) !== null
+}
+
+// find a built-in script in @take-out/scripts, returns path or null
+function findBuiltInScript(name: string): string | null {
   try {
     const resolved = import.meta.resolve('@take-out/scripts/package.json')
     const packageJsonPath = new URL(resolved).pathname
@@ -52,19 +57,22 @@ function isBuiltInScript(name: string): boolean {
     for (const ext of ['.ts', '.js', '']) {
       const scriptPath = join(srcPath, `${normalizedName}${ext}`)
       if (existsSync(scriptPath)) {
-        return true
+        return scriptPath
       }
     }
   } catch {
     // package not found or error resolving
   }
 
-  return false
+  return null
+}
+
+function isBuiltInScript(name: string): boolean {
+  return findBuiltInScript(name) !== null
 }
 
-// detect if running as tko (shorthand mode)
-const isShorthand =
-  process.argv[1]?.endsWith('tko') || process.argv[1]?.includes('/.bin/tko')
+// always enable shorthand mode — both tko and takeout resolve to this file
+const isShorthand = true
 
 if (isShorthand) {
   // in shorthand mode, treat first arg as potential script command
@@ -86,21 +94,27 @@ if (isShorthand) {
   ]
 
   if (firstArg && !builtInCommands.includes(firstArg)) {
+    // resolve the script name for category/script patterns
+    let resolvedScriptName: string | undefined
+
     // check if it's a script category or has a slash (category/script format)
     // Do a lazy check only on the specific arg, not scanning all directories
     if (isScriptCategory(firstArg)) {
       // If there's a second arg, treat it as a script within the category
       // e.g., "tko aws health" becomes "tko run aws/health"
       if (secondArg && !secondArg.startsWith('-')) {
+        resolvedScriptName = `${firstArg}/${secondArg}`
         // Replace the two args with the combined path
-        process.argv.splice(2, 2, `${firstArg}/${secondArg}`)
+        process.argv.splice(2, 2, resolvedScriptName)
       }
       // inject "run" into args to use the run command directly
       process.argv.splice(2, 0, 'run')
     } else if (firstArg?.includes('/')) {
+      resolvedScriptName = firstArg
       // inject "run" into args to use the run command directly
       process.argv.splice(2, 0, 'run')
     } else if (isLocalScript(firstArg) || isBuiltInScript(firstArg)) {
+      resolvedScriptName = firstArg
       // check if it's a local or built-in script (like update-deps, clean, etc.)
       // use "run" to avoid citty parsing issues with hyphens
       process.argv.splice(2, 0, 'run')
@@ -108,6 +122,20 @@ if (isShorthand) {
       // assume it's a script command, inject "script" into args
       process.argv.splice(2, 0, 'script')
     }
+
+    // bypass citty for --help on scripts so the script handles it itself
+    const hasHelp = process.argv.includes('--help') || process.argv.includes('-h')
+    if (resolvedScriptName && hasHelp) {
+      const scriptPath = findLocalScript(resolvedScriptName) || findBuiltInScript(resolvedScriptName)
+      if (scriptPath) {
+        const flagArgs = process.argv.slice(3).filter((a) => a !== resolvedScriptName)
+        const result = spawnSync('bun', [scriptPath, ...flagArgs], {
+          stdio: 'inherit',
+          shell: false,
+        })
+        process.exit(result.status || 0)
+      }
+    }
   }
 }
 
@@ -131,7 +159,7 @@ const main = defineCommand({
     const hasArgs = process.argv.length > 2
     if (!hasArgs) {
       const { listAllScripts } = await import('./utils/script-listing')
-      listAllScripts()
+      await listAllScripts()
     }
   },
 })

package/src/commands/run.ts

@@ -59,7 +59,7 @@ export const runCommand = defineCommand({
         }
 
         // Lazy load script functions only when needed
-        const { discoverScripts, getScriptMetadata } =
+        const { discoverScripts, getAllScriptMetadata } =
           await import('../utils/script-utils')
         const pc = (await import('picocolors')).default
 
@@ -67,21 +67,23 @@ export const runCommand = defineCommand({
         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(pc.bold(pc.cyan(`${firstArg} Scripts`)))
           console.info()
 
-          for (const [name, path] of categoryScripts) {
+          for (const [name] of categoryScripts) {
             const shortName = name.replace(`${firstArg}/`, '')
-            const metadata = getScriptMetadata(path)
+            const meta = metadata.get(name)
             let line = `  ${pc.green(shortName)}`
 
-            if (metadata.description) {
-              line += pc.dim(` - ${metadata.description}`)
+            if (meta?.description) {
+              line += pc.dim(` - ${meta.description}`)
             }
 
-            if (metadata.args && metadata.args.length > 0) {
-              line += pc.dim(` [${metadata.args.join(', ')}]`)
+            if (meta?.args && meta.args.length > 0) {
+              line += pc.dim(` [${meta.args.join(', ')}]`)
             }
 
             console.info(line)

package/src/commands/script.ts

@@ -74,11 +74,7 @@ export function findScript(name: string): string | null {
   return null
 }
 
-export {
-  formatScriptList,
-  listAllScripts,
-  listCategoryScripts,
-} from '../utils/script-listing'
+export { listAllScripts, listCategoryScripts } from '../utils/script-listing'
 
 // run a script
 async function runScript(scriptPath: string, args: string[]): Promise<void> {
@@ -372,12 +368,12 @@ export const scriptCommand = defineCommand({
 
     // if no name provided, list all available scripts
     if (!scriptName) {
-      listAllScripts(false) // don't show built-in commands in script listing
+      await listAllScripts(false)
       return
     }
 
-    // check if this is a category listing (e.g., "takeout script ci")
-    if (listCategoryScripts(scriptName)) {
+    // check if this is a category listing
+    if (await listCategoryScripts(scriptName)) {
       return
     }
 

package/src/index.ts

@@ -1,63 +1 @@
-/**
- * Takeout CLI - Library exports
- *
- * Use these utilities programmatically in your own scripts
- */
-
-// Types
-export type * from './types'
-
-// Prerequisites checking
-export {
-  checkAllPrerequisites,
-  checkBun,
-  checkDocker,
-  checkGit,
-  checkNode,
-  hasRequiredPrerequisites,
-} from './utils/prerequisites'
-
-// Port management
-export {
-  checkAllPorts,
-  checkPort,
-  getConflictingPorts,
-  hasPortConflicts,
-  TAKEOUT_PORTS,
-} from './utils/ports'
-
-// Environment file operations
-export {
-  copyEnvFile,
-  createEnvLocal,
-  envFileExists,
-  generateSecret,
-  readEnvVariable,
-  updateEnvVariable,
-} from './utils/env'
-
-// File operations
-export {
-  checkOnboarded,
-  markOnboarded,
-  updateAppConfig,
-  updatePackageJson,
-} from './utils/files'
-
-// Prompts (for building custom CLIs)
-export {
-  confirmContinue,
-  displayOutro,
-  displayPortConflicts,
-  displayPrerequisites,
-  displayWelcome,
-  promptPassword,
-  promptSelect,
-  promptText,
-  showError,
-  showInfo,
-  showSpinner,
-  showStep,
-  showSuccess,
-  showWarning,
-} from './utils/prompts'
+export { cmd } from '@take-out/scripts/cmd'

package/src/utils/env-setup.ts

@@ -1,15 +1,11 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
 import * as clack from '@clack/prompts'
 import pc from 'picocolors'
 
-import { updateEnvVariable, readEnvVariable, envFileExists, copyEnvFile } from './env'
-import {
-  envCategories,
-  getRequiredCategories,
-  getOptionalCategories,
-} from './env-categories'
+import { copyEnvFile, envFileExists, readEnvVariable, updateEnvVariable } from './env'
+import { envCategories } from './env-categories'
 
 import type { EnvCategory, EnvVariable } from '../types'
 

package/src/utils/script-listing.ts

@@ -8,13 +8,17 @@ import { fileURLToPath } from 'node:url'
 
 import pc from 'picocolors'
 
-import { discoverScripts, getLocalScriptsDir, getScriptMetadata } from './script-utils'
+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('@take-out/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')
@@ -22,18 +26,18 @@ function findScriptsPackageRoot(): string | null {
     if (existsSync(srcPath)) {
       return srcPath
     }
-  } catch (err) {
-    // scripts package not found, that's ok for hybrid mode
+  } catch {
+    // scripts package not found
   }
 
   return null
 }
 
-// format script listing
-export function formatScriptList(
+// format script listing with pre-fetched metadata
+function formatScriptList(
   title: string,
   scripts: Map<string, string>,
-  showDescriptions: boolean = false
+  metadata: Map<string, ScriptMetadata>
 ): void {
   if (scripts.size === 0) return
 
@@ -41,65 +45,48 @@ export function formatScriptList(
   console.info(pc.bold(pc.cyan(title)))
   console.info()
 
-  // group by category
   const categories = new Map<string, Array<[string, string]>>()
   const rootScripts: Array<[string, string]> = []
 
   for (const [name, path] of scripts) {
     if (name.includes('/')) {
-      const parts = name.split('/')
-      if (parts.length > 0 && parts[0]) {
-        const category = parts[0]
-        if (!categories.has(category)) {
-          categories.set(category, [])
-        }
-        categories.get(category)!.push([name, path])
+      const category = name.split('/')[0]!
+      if (!categories.has(category)) {
+        categories.set(category, [])
       }
+      categories.get(category)!.push([name, path])
     } else {
       rootScripts.push([name, path])
     }
   }
 
-  // display root scripts
-  for (const [name, path] of rootScripts) {
+  for (const [name] of rootScripts) {
     let line = `  ${pc.green(name)}`
-
-    if (showDescriptions) {
-      const metadata = getScriptMetadata(path)
-      if (metadata.description) {
-        line += pc.dim(` - ${metadata.description}`)
-      }
+    const meta = metadata.get(name)
+    if (meta?.description) {
+      line += pc.dim(` - ${meta.description}`)
     }
-
     console.info(line)
   }
 
-  // display categorized scripts
   for (const [category, categoryScripts] of categories) {
     console.info()
     console.info(`  ${pc.yellow(category)}/`)
 
-    for (const [name, path] of categoryScripts) {
-      const shortName = name.startsWith(`${category}/`)
-        ? name.substring(category.length + 1)
-        : name
+    for (const [name] of categoryScripts) {
+      const shortName = name.substring(category.length + 1)
       let line = `    ${pc.green(shortName)}`
-
-      if (showDescriptions) {
-        const metadata = getScriptMetadata(path)
-        if (metadata.description) {
-          line += pc.dim(` - ${metadata.description}`)
-        }
+      const meta = metadata.get(name)
+      if (meta?.description) {
+        line += pc.dim(` - ${meta.description}`)
       }
-
       console.info(line)
     }
   }
 }
 
-// list all available scripts (local and built-in)
-export function listAllScripts(includeCommands = true): void {
-  // show header with description
+// 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()
@@ -107,8 +94,7 @@ export function listAllScripts(includeCommands = true): void {
   console.info()
 
   if (includeCommands) {
-    // Show built-in CLI commands
-    console.info(pc.bold(pc.cyan('🛠️  Built-in Commands')))
+    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`)
@@ -124,70 +110,60 @@ export function listAllScripts(includeCommands = true): void {
   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, true)
+    formatScriptList('Local Scripts', localScripts, metadata)
   }
 
   if (builtInScripts.size > 0) {
-    formatScriptList('📦 Built-in Scripts', builtInScripts, true)
+    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(`Create scripts in ${relative(process.cwd(), getLocalScriptsDir())}/`))
     console.info(pc.dim(`Or install @take-out/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 (e.g., tko onboard)')}`
-  )
-  console.info(
-    `  ${pc.cyan('tko <group-name> <script-name>')}       ${pc.dim('Execute nested script (e.g., tko web build)')}`
-  )
+  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()
-  console.info(pc.bold('Examples:'))
-  console.info(`  ${pc.cyan('tko web build')}           ${pc.dim('Build web platform')}`)
-  console.info(
-    `  ${pc.cyan('tko check types')}         ${pc.dim('Run TypeScript type checking')}`
-  )
-  console.info()
 }
 
 // check if a name is a category and list its scripts
-export function listCategoryScripts(categoryName: string): boolean {
+export async function listCategoryScripts(categoryName: string): Promise<boolean> {
   const localDir = getLocalScriptsDir()
   const categoryPath = join(localDir, categoryName)
 
   if (existsSync(categoryPath) && statSync(categoryPath).isDirectory()) {
-    // 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(`📁 ${categoryName} Scripts`)))
+      console.info(pc.bold(pc.cyan(`${categoryName} Scripts`)))
       console.info()
 
-      for (const [name, path] of categoryScripts) {
+      for (const [name] of categoryScripts) {
         const shortName = name.replace(`${categoryName}/`, '')
-        const metadata = getScriptMetadata(path)
+        const meta = metadata.get(name)
         let line = `  ${pc.green(shortName)}`
 
-        if (metadata.description) {
-          line += pc.dim(` - ${metadata.description}`)
+        if (meta?.description) {
+          line += pc.dim(` - ${meta.description}`)
         }
 
-        if (metadata.args && metadata.args.length > 0) {
-          line += pc.dim(` [${metadata.args.join(', ')}]`)
+        if (meta?.args && meta.args.length > 0) {
+          line += pc.dim(` [${meta.args.join(', ')}]`)
         }
 
         console.info(line)