@take-out/cli 0.0.39

package/src/utils/prompts.ts

@@ -0,0 +1,197 @@
+/**
+ * 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(): 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',
+    },
+    {
+      value: 'eject',
+      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/utils/script-listing.ts

@@ -0,0 +1,214 @@
+/**
+ * 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'
+
+// re-export needed functions from script command
+import {
+  discoverScripts,
+  getLocalScriptsDir,
+  getScriptMetadata,
+} from '../commands/script'
+
+// 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')
+
+    if (existsSync(srcPath)) {
+      return srcPath
+    }
+  } catch (err) {
+    // scripts package not found, that's ok for hybrid mode
+  }
+
+  return null
+}
+
+// format script listing
+export function formatScriptList(
+  title: string,
+  scripts: Map<string, string>,
+  showDescriptions: boolean = false
+): void {
+  if (scripts.size === 0) return
+
+  console.info()
+  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])
+      }
+    } else {
+      rootScripts.push([name, path])
+    }
+  }
+
+  // display root scripts
+  for (const [name, path] of rootScripts) {
+    let line = `  ${pc.green(name)}`
+
+    if (showDescriptions) {
+      const metadata = getScriptMetadata(path)
+      if (metadata.description) {
+        line += pc.dim(` - ${metadata.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
+      let line = `    ${pc.green(shortName)}`
+
+      if (showDescriptions) {
+        const metadata = getScriptMetadata(path)
+        if (metadata.description) {
+          line += pc.dim(` - ${metadata.description}`)
+        }
+      }
+
+      console.info(line)
+    }
+  }
+}
+
+// list all available scripts (local and built-in)
+export function listAllScripts(includeCommands = true): void {
+  // show header with description
+  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) {
+    // Show built-in CLI 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`)
+    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('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()
+
+  if (localScripts.size > 0) {
+    formatScriptList('📁 Local Scripts', localScripts, true)
+  }
+
+  if (builtInScripts.size > 0) {
+    formatScriptList('📦 Built-in Scripts', builtInScripts, true)
+  }
+
+  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 @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 a script (use / for nested, e.g., tko web/build)')}`
+  )
+  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 upgrade/tamagui')}     ${pc.dim('Upgrade Tamagui packages')}`
+  )
+  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 {
+  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) {
+      console.info()
+      console.info(pc.bold(pc.cyan(`📁 ${categoryName} Scripts`)))
+      console.info()
+
+      for (const [name, path] of categoryScripts) {
+        const shortName = name.replace(`${categoryName}/`, '')
+        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 ${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/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/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

package/types/cli.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Takeout CLI
+ * Interactive tools for Takeout starter kit setup and management
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/types/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAEA;;;GAGG"}

package/types/commands/changed.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Changed command - show what's changed in upstream Takeout since last sync
+ */
+export declare const changedCommand: import("citty").CommandDef<{
+    from: {
+        type: "string";
+        description: string;
+    };
+    to: {
+        type: "string";
+        description: string;
+    };
+}>;
+//# sourceMappingURL=changed.d.ts.map

package/types/commands/changed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changed.d.ts","sourceRoot":"","sources":["../../src/commands/changed.ts"],"names":[],"mappings":"AAAA;;GAEG;AA2OH,eAAO,MAAM,cAAc;;;;;;;;;EA2EzB,CAAA"}

package/types/commands/docs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Docs command - list and retrieve documentation files from the package
+ */
+export declare const docsCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=docs.d.ts.map

package/types/commands/docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/commands/docs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAujBH,eAAO,MAAM,WAAW,qDAYtB,CAAA"}

package/types/commands/env-setup.d.ts

@@ -0,0 +1,25 @@
+export declare const envSetupCommand: import("citty").CommandDef<{
+    category: {
+        type: "string";
+        description: string;
+        alias: string;
+    };
+    file: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string;
+    };
+    list: {
+        type: "boolean";
+        description: string;
+        alias: string;
+        default: false;
+    };
+    'skip-optional': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+//# sourceMappingURL=env-setup.d.ts.map

package/types/commands/env-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-setup.d.ts","sourceRoot":"","sources":["../../src/commands/env-setup.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;EA+D1B,CAAA"}

package/types/commands/onboard.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Onboard command - interactive setup for Takeout starter kit
+ */
+export declare const onboardCommand: import("citty").CommandDef<{
+    skip: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    defaults: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+//# sourceMappingURL=onboard.d.ts.map

package/types/commands/onboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboard.d.ts","sourceRoot":"","sources":["../../src/commands/onboard.ts"],"names":[],"mappings":"AAAA;;GAEG;AA4CH,eAAO,MAAM,cAAc;;;;;;;;;;;EA0czB,CAAA"}

package/types/commands/run.d.ts

@@ -0,0 +1,8 @@
+export declare const runCommand: import("citty").CommandDef<{
+    scripts: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=run.d.ts.map

package/types/commands/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU;;;;;;EAsKrB,CAAA"}

package/types/commands/script.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Enhanced Script command - hybrid script runner with filesystem discovery
+ */
+interface ScriptMetadata {
+    description?: string;
+    args?: string[];
+    mtime?: number;
+}
+export declare function getLocalScriptsDir(): string;
+export declare function getScriptMetadata(filePath: string): ScriptMetadata;
+export declare function discoverScripts(dir: string, baseDir?: string, depth?: number, maxDepth?: number): Map<string, string>;
+export declare function findScript(name: string): string | null;
+export { formatScriptList, listAllScripts, listCategoryScripts, } from '../utils/script-listing';
+export declare const scriptCommand: import("citty").CommandDef<{
+    name: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+}>;
+export declare function createShorthandCommand(name: string): import("citty").CommandDef<{
+    args: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=script.d.ts.map