@o/cli 0.16.18 → 0.16.19-canary.1790191946359

package/src/tko/commands/skills.ts

@@ -0,0 +1,288 @@
+/**
+ * skills command group - manage repository agent skills
+ */
+
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  readlinkSync,
+  rmSync,
+  rmdirSync,
+  symlinkSync,
+  unlinkSync,
+} from 'node:fs'
+import { join, relative, resolve } from 'node:path'
+
+import { defineCommand } from 'citty'
+import pc from 'picocolors'
+
+// --- doc skills generation ---
+
+const SKILL_PREFIX = 'takeout-'
+
+function getSkillsDirs(cwd: string): string[] {
+  return [join(cwd, '.claude', 'skills'), join(cwd, '.agents', 'skills')]
+}
+
+function hasSkillFrontmatter(content: string): boolean {
+  if (!content.startsWith('---')) return false
+  const endIndex = content.indexOf('---', 3)
+  if (endIndex === -1) return false
+  const frontmatter = content.slice(3, endIndex)
+  return frontmatter.includes('name:') && frontmatter.includes('description:')
+}
+
+function isDevOnly(content: string): boolean {
+  if (!content.startsWith('---')) return false
+  const endIndex = content.indexOf('---', 3)
+  if (endIndex === -1) return false
+  const frontmatter = content.slice(3, endIndex)
+  return /\bdev:\s*true\b/.test(frontmatter)
+}
+
+// prefer a project's ./skills dir if it exists, else fall back to ./docs. lets
+// consumers cleanly separate agent skills (frontmatter md) from plain docs.
+function resolveLocalDocsDir(cwd: string): string {
+  const skillsDir = join(cwd, 'skills')
+  if (existsSync(skillsDir)) return skillsDir
+  return join(cwd, 'docs')
+}
+
+function collectAllDocs(cwd: string): Array<{ name: string; path: string }> {
+  const docs: Array<{ name: string; path: string }> = []
+
+  const localDocsDir = resolveLocalDocsDir(cwd)
+  if (existsSync(localDocsDir)) {
+    const files = readdirSync(localDocsDir).filter((f) => f.endsWith('.md'))
+    for (const file of files) {
+      const name = file.replace(/\.md$/, '')
+      docs.push({ name, path: join(localDocsDir, file) })
+    }
+  }
+
+  return docs
+}
+
+async function generateDocSkills(
+  cwd: string,
+  clean: boolean
+): Promise<{
+  symlinked: number
+  generated: number
+  unchanged: number
+  removed: number
+  skipped: number
+}> {
+  const skillsDirs = getSkillsDirs(cwd)
+  const docs = collectAllDocs(cwd)
+  const localDocsDir = resolveLocalDocsDir(cwd)
+  const expectedSkillNames = new Set<string>()
+
+  if (docs.length === 0) {
+    console.info(pc.yellow('no documentation files found'))
+  } else {
+    console.info(pc.dim(`found ${docs.length} documentation files`))
+  }
+
+  for (const skillsDir of skillsDirs) {
+    if (clean && existsSync(skillsDir)) {
+      const existing = readdirSync(skillsDir)
+      for (const dir of existing) {
+        if (dir.startsWith(SKILL_PREFIX)) {
+          rmSync(join(skillsDir, dir), { recursive: true })
+        }
+      }
+    }
+
+    if (!existsSync(skillsDir)) {
+      mkdirSync(skillsDir, { recursive: true })
+    }
+  }
+
+  let symlinked = 0
+  let generated = 0
+  let unchanged = 0
+  let removed = 0
+  let skipped = 0
+  const isDev = !!process.env.IS_TAMAGUI_DEV
+
+  for (const doc of docs) {
+    const content = readFileSync(doc.path, 'utf-8')
+    if (isDevOnly(content) && !isDev) continue
+
+    const hasFrontmatter = hasSkillFrontmatter(content)
+
+    if (hasFrontmatter) {
+      const nameMatch = content.match(/^---\s*\nname:\s*([^\n]+)/m)
+      if (!nameMatch) continue
+
+      const skillName = nameMatch[1]!.trim()
+      expectedSkillNames.add(skillName)
+
+      for (const skillsDir of skillsDirs) {
+        const skillDir = join(skillsDir, skillName)
+        const skillFile = join(skillDir, 'SKILL.md')
+
+        if (!existsSync(skillDir)) {
+          mkdirSync(skillDir, { recursive: true })
+        }
+
+        const relativePath = relative(skillDir, doc.path)
+
+        let shouldCreate = true
+        try {
+          const stat = lstatSync(skillFile)
+          if (stat.isSymbolicLink() && existsSync(skillFile)) {
+            const existingContent = readFileSync(skillFile, 'utf-8')
+            if (existingContent === content) {
+              unchanged++
+              shouldCreate = false
+            }
+          }
+          if (shouldCreate) {
+            unlinkSync(skillFile)
+          }
+        } catch {
+          // nothing exists
+        }
+
+        if (!shouldCreate) continue
+
+        symlinkSync(relativePath, skillFile)
+        symlinked++
+
+        console.info(
+          `  ${pc.green('⟷')} ${skillName} ${pc.dim(`(${relative(cwd, skillsDir)})`)}`
+        )
+      }
+    } else {
+      if (!hasFrontmatter) {
+        skipped++
+        console.info(
+          `  ${pc.yellow('!')} skipped ${pc.dim(doc.name)} ${pc.dim('(missing skill frontmatter)')}`
+        )
+        continue
+      }
+    }
+  }
+
+  for (const skillsDir of skillsDirs) {
+    for (const dir of readdirSync(skillsDir)) {
+      if (expectedSkillNames.has(dir)) continue
+
+      const skillDir = join(skillsDir, dir)
+      const skillFile = join(skillDir, 'SKILL.md')
+
+      if (dir.startsWith(SKILL_PREFIX)) {
+        rmSync(skillDir, { recursive: true, force: true })
+        removed++
+        console.info(
+          `  ${pc.red('✕')} ${dir} ${pc.dim('(removed stale generated skill)')}`
+        )
+        continue
+      }
+
+      let shouldUnlink = false
+
+      try {
+        const stat = lstatSync(skillFile)
+        if (stat.isSymbolicLink()) {
+          const linkTarget = readlinkSync(skillFile)
+          const resolvedTarget = resolve(skillDir, linkTarget)
+          shouldUnlink = resolvedTarget.startsWith(`${localDocsDir}/`)
+        }
+      } catch {
+        // ignore unrelated skill directories
+      }
+
+      if (!shouldUnlink) continue
+
+      unlinkSync(skillFile)
+      if (readdirSync(skillDir).length === 0) {
+        rmdirSync(skillDir)
+      }
+      removed++
+      console.info(`  ${pc.red('✕')} ${dir} ${pc.dim('(removed stale symlink)')}`)
+    }
+  }
+
+  return { symlinked, generated, unchanged, removed, skipped }
+}
+
+// --- commands ---
+
+const generateCommand = defineCommand({
+  meta: {
+    name: 'generate',
+    description: 'Generate Claude Code and Codex skills from documentation',
+  },
+  args: {
+    clean: {
+      type: 'boolean',
+      description: 'Remove existing takeout-* skills before generating',
+      default: false,
+    },
+    'skip-internal-docs': {
+      type: 'boolean',
+      description: 'Skip generating skills from internal documentation files',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const cwd = process.cwd()
+    const skillsDirs = getSkillsDirs(cwd)
+
+    console.info()
+    console.info(pc.bold(pc.cyan('Generate all skills')))
+    console.info()
+
+    let symlinked = 0
+    let generated = 0
+    let unchanged = 0
+    let removed = 0
+    let skipped = 0
+
+    // 1. doc skills (unless skipped)
+    if (!args['skip-internal-docs']) {
+      const docStats = await generateDocSkills(cwd, args.clean)
+      symlinked = docStats.symlinked
+      generated = docStats.generated
+      unchanged = docStats.unchanged
+      removed = docStats.removed
+      skipped = docStats.skipped
+      console.info()
+    }
+
+    // summary
+    console.info()
+    console.info(pc.bold('summary:'))
+    if (symlinked > 0) console.info(`  ${pc.green(`${symlinked} symlinked`)}`)
+    if (generated > 0)
+      console.info(
+        `  ${pc.yellow(`${generated} generated`)} ${pc.dim('(add frontmatter to enable symlink)')}`
+      )
+    if (skipped > 0)
+      console.info(
+        `  ${pc.yellow(`${skipped} skipped`)} ${pc.dim('(missing skill frontmatter)')}`
+      )
+    if (unchanged > 0) console.info(`  ${pc.dim(`${unchanged} unchanged`)}`)
+    if (removed > 0) console.info(`  ${pc.red(`${removed} removed`)}`)
+    for (const skillsDir of skillsDirs) {
+      console.info(pc.dim(`  skills in ${skillsDir}`))
+    }
+    console.info()
+  },
+})
+
+export const skillsCommand = defineCommand({
+  meta: {
+    name: 'skills',
+    description: 'Manage repository agent skills',
+  },
+  subCommands: {
+    generate: generateCommand,
+  },
+})

package/src/tko/commands/sync.ts

@@ -0,0 +1,319 @@
+/**
+ * Sync command - sync fork with upstream Takeout repository
+ */
+
+import { execSync, spawn, spawnSync } from 'node:child_process'
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { defineCommand } from 'citty'
+import pc from 'picocolors'
+
+import {
+  confirmContinue,
+  promptSelect,
+  showError,
+  showInfo,
+  showStep,
+  showSuccess,
+} from '../utils/prompts'
+
+const UPSTREAM_REPO = 'tamagui/takeout2'
+const UPSTREAM_REMOTE = 'takeout-upstream'
+const TAKEOUT_FILE = '.takeout'
+
+function getSyncPrompt(): string {
+  const promptPath = join(process.cwd(), 'docs', 'upgrade.md')
+  if (!existsSync(promptPath)) {
+    throw new Error(
+      'Missing docs/upgrade.md. Copy it from https://github.com/tamagui/takeout2/blob/main/docs/upgrade.md and rerun `bun tko sync`.'
+    )
+  }
+
+  return readFileSync(promptPath, 'utf-8')
+}
+
+function checkToolAvailable(command: string): boolean {
+  try {
+    // use 'where' on windows, 'which' on unix
+    const checkCmd = process.platform === 'win32' ? 'where' : 'which'
+    const result = spawnSync(checkCmd, [command])
+    return result.status === 0
+  } catch {
+    return false
+  }
+}
+
+function ensureUpstreamRemote(): boolean {
+  try {
+    // check if remote exists
+    const remotes = execSync('git remote', { encoding: 'utf-8' })
+    if (!remotes.includes(UPSTREAM_REMOTE)) {
+      execSync(`git remote add ${UPSTREAM_REMOTE} git@github.com:${UPSTREAM_REPO}.git`, {
+        stdio: 'pipe',
+      })
+    }
+    execSync(`git fetch ${UPSTREAM_REMOTE} --quiet`, { stdio: 'pipe' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+function getUpstreamHeadSha(): string | null {
+  try {
+    const sha = execSync(`git rev-parse ${UPSTREAM_REMOTE}/main`, { encoding: 'utf-8' })
+    return sha.trim()
+  } catch {
+    return null
+  }
+}
+
+function writeTakeoutConfig(sha: string): void {
+  const configPath = join(process.cwd(), TAKEOUT_FILE)
+  const date = new Date().toISOString().split('T')[0]
+  const content = `# takeout sync tracking file
+# this file tracks the last synced commit from upstream takeout
+sha=${sha}
+date=${date}
+`
+  writeFileSync(configPath, content)
+}
+
+export const syncCommand = defineCommand({
+  meta: {
+    name: 'sync',
+    description: 'Sync your fork with the latest Takeout repository',
+  },
+  args: {
+    auto: {
+      type: 'boolean',
+      description: 'Auto-run with claude-code without prompts (for non-TTY environments)',
+      default: false,
+    },
+    print: {
+      type: 'boolean',
+      description: 'Print the sync prompt and exit',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const isAuto = args.auto
+    const isPrint = args.print
+    showStep('Takeout Repository Sync')
+    console.info()
+
+    if (!isAuto && !isPrint) {
+      showInfo('Takeout sync uses AI to intelligently merge upstream changes')
+      console.info()
+      console.info(pc.gray('How it works:'))
+      console.info(pc.gray('  • Analyzes commits from upstream Takeout repository'))
+      console.info(pc.gray('  • Determines which changes are relevant to your fork'))
+      console.info(pc.gray('  • Applies changes while preserving your customizations'))
+      console.info(pc.gray('  • Handles package ejection automatically'))
+      console.info(pc.gray('  • Asks for your input when decisions are needed'))
+      console.info()
+    }
+
+    // check what tools are available
+    const hasClaudeCode = checkToolAvailable('claude')
+    const hasCursor = checkToolAvailable('cursor-agent')
+    const hasAider = checkToolAvailable('aider')
+
+    // handle --auto mode
+    let choice: string
+    if (isAuto) {
+      if (!hasClaudeCode) {
+        showError('--auto requires claude CLI to be installed')
+        process.exit(1)
+      }
+      choice = 'claude-code'
+    } else if (isPrint) {
+      choice = 'show-prompt'
+    } else {
+      const options: Array<{
+        value: string
+        label: string
+        hint: string
+      }> = []
+
+      if (hasClaudeCode) {
+        options.push({
+          value: 'claude-code',
+          label: 'Claude Code (recommended)',
+          hint: 'Run sync automatically with Claude Code CLI',
+        })
+      }
+
+      if (hasCursor) {
+        options.push({
+          value: 'cursor',
+          label: 'Cursor Agent',
+          hint: 'Run sync automatically with Cursor CLI',
+        })
+      }
+
+      if (hasAider) {
+        options.push({
+          value: 'aider',
+          label: 'Aider',
+          hint: 'Run sync automatically with Aider CLI',
+        })
+      }
+
+      options.push({
+        value: 'show-prompt',
+        label: 'Show prompt (copy & paste manually)',
+        hint: 'Display the full prompt to use with any LLM',
+      })
+
+      choice = await promptSelect<string>('How would you like to sync?', options)
+
+      if (choice === 'cancel') {
+        console.info()
+        showInfo('Sync cancelled')
+        return
+      }
+
+      console.info()
+    }
+
+    // fetch upstream to get the target SHA before syncing
+    console.info(pc.dim('Fetching upstream repository...'))
+    if (!ensureUpstreamRemote()) {
+      showError('Failed to fetch upstream repository')
+      return
+    }
+
+    const upstreamSha = getUpstreamHeadSha()
+    if (!upstreamSha) {
+      showError('Failed to get upstream HEAD SHA')
+      return
+    }
+    console.info(pc.dim(`Target SHA: ${upstreamSha.slice(0, 7)}`))
+    console.info()
+
+    try {
+      const prompt = getSyncPrompt()
+
+      if (choice === 'show-prompt') {
+        console.info(pc.dim('='.repeat(80)))
+        console.info(prompt)
+        console.info(pc.dim('='.repeat(80)))
+        console.info()
+        showInfo('Copy the prompt above and paste it into your preferred LLM')
+        console.info()
+        console.info(pc.gray('Recommended LLMs:'))
+        console.info(pc.gray('  • Claude Code (best for complex instructions)'))
+        console.info(pc.gray('  • ChatGPT'))
+        console.info(pc.gray('  • Cursor'))
+        console.info(pc.gray('  • Aider'))
+        console.info()
+      } else if (choice === 'claude-code') {
+        showInfo('Starting Claude Code with sync prompt...')
+        console.info()
+
+        if (!isAuto) {
+          console.info(
+            pc.dim(
+              'Note: Claude Code will run in headless mode and make changes automatically.'
+            )
+          )
+          console.info(pc.dim('You will be asked to confirm important decisions.'))
+          console.info()
+
+          const shouldContinue = await confirmContinue('Continue with Claude Code?', true)
+          if (!shouldContinue) {
+            showInfo('Sync cancelled')
+            return
+          }
+        }
+
+        // write prompt to temp file to avoid shell escaping issues
+        const tempDir = mkdtempSync(join(tmpdir(), 'takeout-sync-'))
+        const promptFile = join(tempDir, 'prompt.md')
+        writeFileSync(promptFile, prompt)
+
+        // run claude with prompt from stdin
+        const claude = spawn('claude', ['-p', '-'], {
+          stdio: ['pipe', 'inherit', 'inherit'],
+        })
+
+        claude.stdin?.write(prompt)
+        claude.stdin?.end()
+
+        claude.on('close', (code) => {
+          console.info()
+          if (code === 0) {
+            writeTakeoutConfig(upstreamSha)
+            showSuccess('Sync completed successfully!')
+            console.info(pc.dim(`Updated .takeout to ${upstreamSha.slice(0, 7)}`))
+          } else {
+            showError(`Claude Code exited with code ${code}`)
+          }
+        })
+      } else if (choice === 'cursor') {
+        showInfo('Starting Cursor Agent with sync prompt...')
+        console.info()
+
+        const shouldContinue = await confirmContinue('Continue with Cursor?', true)
+        if (!shouldContinue) {
+          showInfo('Sync cancelled')
+          return
+        }
+
+        // run cursor agent with prompt from stdin
+        const cursor = spawn('cursor-agent', ['-p', '-'], {
+          stdio: ['pipe', 'inherit', 'inherit'],
+        })
+
+        cursor.stdin?.write(prompt)
+        cursor.stdin?.end()
+
+        cursor.on('close', (code) => {
+          console.info()
+          if (code === 0) {
+            writeTakeoutConfig(upstreamSha)
+            showSuccess('Sync completed successfully!')
+            console.info(pc.dim(`Updated .takeout to ${upstreamSha.slice(0, 7)}`))
+          } else {
+            showError(`Cursor Agent exited with code ${code}`)
+          }
+        })
+      } else if (choice === 'aider') {
+        showInfo('Starting Aider with sync prompt...')
+        console.info()
+
+        const shouldContinue = await confirmContinue('Continue with Aider?', true)
+        if (!shouldContinue) {
+          showInfo('Sync cancelled')
+          return
+        }
+
+        // write prompt to temp file for aider
+        const tempDir = mkdtempSync(join(tmpdir(), 'takeout-sync-'))
+        const promptFile = join(tempDir, 'prompt.md')
+        writeFileSync(promptFile, prompt)
+
+        // run aider with message from file
+        const aider = spawn('aider', ['--message-file', promptFile, '--no-stream'], {
+          stdio: 'inherit',
+        })
+
+        aider.on('close', (code) => {
+          console.info()
+          if (code === 0) {
+            writeTakeoutConfig(upstreamSha)
+            showSuccess('Sync completed successfully!')
+            console.info(pc.dim(`Updated .takeout to ${upstreamSha.slice(0, 7)}`))
+          } else {
+            showError(`Aider exited with code ${code}`)
+          }
+        })
+      }
+    } catch (error) {
+      showError(error instanceof Error ? error.message : 'Unknown error')
+    }
+  },
+})

package/src/tko/constants/ascii.ts

@@ -0,0 +1,17 @@
+/**
+ * ASCII art constants for Takeout branding
+ */
+
+// TAKEOUT in block letters with chinese accent line
+// chinese chars: 麵(noodles) 碼(code) 飯(rice)
+export const TAKEOUT_ASCII = `
+████████╗ █████╗ ██╗  ██╗███████╗ ██████╗ ██╗   ██╗████████╗
+╚══██╔══╝██╔══██╗██║ ██╔╝██╔════╝██╔═══██╗██║   ██║╚══██╔══╝
+   ██║   ███████║█████╔╝ █████╗  ██║   ██║██║   ██║   ██║
+   ██║   ██╔══██║██╔═██╗ ██╔══╝  ██║   ██║██║   ██║   ██║
+   ██║   ██║  ██║██║  ██╗███████╗╚██████╔╝╚██████╔╝   ██║
+   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝ ╚═════╝  ╚═════╝    ╚═╝
+                        麵 碼 飯
+`.trim()
+
+export const WELCOME_BANNER = TAKEOUT_ASCII

package/src/tko/index.ts

@@ -0,0 +1 @@
+export { cmd } from '@o/scripts/cmd'

package/src/tko/types.ts

@@ -0,0 +1,59 @@
+export interface PrerequisiteCheck {
+  name: string
+  required: boolean
+  installed: boolean
+  version?: string
+  requiredVersion?: string
+  message?: string
+  installUrl?: string
+  recommendation?: string
+}
+
+export interface PortCheck {
+  port: number
+  name: string
+  inUse: boolean
+  pid?: number
+}
+
+export interface ProjectIdentity {
+  name: string
+  bundleId: string
+  domain: string
+}
+
+export interface OnboardingConfig {
+  skipPrerequisites?: boolean
+  skipServices?: boolean
+  skipMigrations?: boolean
+  autoStart?: boolean
+}
+
+export interface EnvironmentSetup {
+  authSecret: string
+  githubClientId?: string
+  githubClientSecret?: string
+  domain: string
+  serverUrl: string
+}
+
+export interface EnvVariable {
+  key: string
+  label: string
+  description: string
+  instructions: string
+  required: boolean
+  type: 'text' | 'secret' | 'multiline'
+  default?: string
+  placeholder?: string
+  generator?: () => string
+}
+
+export interface EnvCategory {
+  id: string
+  name: string
+  description: string
+  required: boolean
+  setupTime?: string
+  variables: EnvVariable[]
+}