@jayrdeaton/scripts 1.0.0 → 1.1.0

package/src/commands/code-count.mjs

@@ -1,19 +1,11 @@
 import { createReadStream, existsSync, lstatSync, readdirSync } from 'node:fs'
 import { extname, join, resolve } from 'node:path'
 
-import cosmetic from 'cosmetic'
-import { command as createCommand } from 'termkit'
+import { Color, command as createCommand, Spinner } from 'termkit'
 
-const WHITELIST = new Set([
-  '.cjs', '.css', '.csv', '.ejs', '.env', '.gitignore', '.haml', '.html', '.java',
-  '.js', '.json', '.mjs', '.paw', '.plist', '.py', '.rake', '.scss', '.sh', '.sql',
-  '.stl', '.swift', '.ts', '.tsx', '.txt', '.xib', '.xml', '.yaml', '.yml',
-])
+const WHITELIST = new Set(['.cjs', '.css', '.csv', '.ejs', '.env', '.gitignore', '.haml', '.html', '.java', '.js', '.json', '.mjs', '.paw', '.plist', '.py', '.rake', '.scss', '.sh', '.sql', '.stl', '.swift', '.ts', '.tsx', '.txt', '.xib', '.xml', '.yaml', '.yml'])
 
-const SKIP = new Set([
-  '.DS_Store', '.git', 'Carthage', 'Dockerfile', 'LICENSE', 'Test',
-  'node_modules', 'package-lock.json',
-])
+const SKIP = new Set(['.DS_Store', '.git', 'Carthage', 'Dockerfile', 'LICENSE', 'Test', 'node_modules', 'package-lock.json'])
 
 function getFiles(base, { ignore = [], recursive = false } = {}) {
   try {
@@ -69,19 +61,22 @@ export const command = createCommand('code-count')
 
     const allPaths = paths.flatMap((p) => getFiles(p, { ignore, recursive }))
 
+    const spinner = new Spinner({ text: 'Scanning...' })
+    spinner.start()
+
     const totals = {}
     for (let i = 0; i < allPaths.length; i++) {
       const path = allPaths[i]
       const ext = extname(path)
       if (!ext) continue
-      process.stdout.write(`checking files ${i + 1} / ${allPaths.length}\r`)
+      spinner.message(`Checking files ${i + 1} / ${allPaths.length}`)
       totals[ext] = (totals[ext] ?? 0) + (await countLines(path))
     }
-    if (process.stdout.clearLine) process.stdout.clearLine(0)
+
+    const total = Object.values(totals).reduce((a, n) => a + n, 0)
+    spinner.succeed(`${commaString(total)} lines across ${allPaths.length} files`)
 
     for (const key of Object.keys(totals).sort()) {
-      console.log(`${key}: ${cosmetic.cyan(commaString(totals[key]))}`)
+      console.log(`${key}: ${Color.cyan(commaString(totals[key]))}`)
     }
-    const total = Object.values(totals).reduce((a, n) => a + n, 0)
-    console.log(`total ${cosmetic.cyan(commaString(total))} in ${cosmetic.cyan(String(allPaths.length))} files`)
   })

package/src/commands/find-dep.mjs

@@ -0,0 +1,95 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+import { Color, command as createCommand, Spinner } from 'termkit'
+
+const DEP_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies']
+
+function findMatches(pkgPath, targets) {
+  let pkg
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+  } catch {
+    return null
+  }
+
+  const found = []
+  for (const field of DEP_FIELDS) {
+    if (!pkg[field]) continue
+    for (const target of targets) {
+      if (pkg[field][target] !== undefined) {
+        found.push({ name: target, version: pkg[field][target], field })
+      }
+    }
+  }
+
+  return found.length ? { projectName: pkg.name, found } : null
+}
+
+export const command = createCommand('find-dep', '[deps...]')
+  .description('Find projects in a directory that use any of the given dependencies')
+  .option('d', 'dir', '[dir]', 'Root directory to scan (default: ~/Developer)')
+  .action(async (options) => {
+    const targets = options.deps ?? []
+
+    if (!targets.length) {
+      console.error(Color.red('Provide at least one dependency name.'))
+      process.exit(1)
+    }
+
+    const root = resolve(options.dir ?? join(homedir(), 'Developer'))
+
+    let entries
+    try {
+      entries = readdirSync(root)
+    } catch {
+      console.error(Color.red(`Could not read directory: ${root}`))
+      process.exit(1)
+    }
+
+    const spinner = new Spinner({ text: 'Scanning projects...' })
+    spinner.start()
+
+    const results = []
+
+    for (const name of entries) {
+      const dir = join(root, name)
+      try {
+        if (!statSync(dir).isDirectory()) continue
+      } catch {
+        continue
+      }
+
+      spinner.message(name)
+      const pkgPath = join(dir, 'package.json')
+      const match = findMatches(pkgPath, targets)
+      if (match) results.push({ dir: name, ...match })
+    }
+
+    if (!results.length) {
+      spinner.succeed(`No projects found using: ${targets.join(', ')}`)
+      return
+    }
+
+    spinner.stop()
+
+    console.log(Color.bold(`\nFound ${results.length} project${results.length !== 1 ? 's' : ''}:\n`))
+
+    for (const result of results) {
+      const label = result.projectName && result.projectName !== result.dir
+        ? `${Color.bold(result.dir)} ${Color.faint(`(${result.projectName})`)}`
+        : Color.bold(result.dir)
+
+      console.log(`  ${label}`)
+
+      for (const dep of result.found) {
+        const fieldLabel = dep.field === 'dependencies' ? 'dep'
+          : dep.field === 'devDependencies' ? 'dev'
+          : 'peer'
+        console.log(`    ${Color.cyan(dep.name)}  ${Color.faint(`${dep.version}  [${fieldLabel}]`)}`)
+      }
+    }
+
+    console.log()
+  })

package/src/commands/focus.mjs

@@ -0,0 +1,11 @@
+import { execSync } from 'node:child_process'
+
+import { command as createCommand } from 'termkit'
+
+export const command = createCommand('focus')
+  .description('Bring an application to the front')
+  .variable('[app]')
+  .action((args) => {
+    const app = args.app ?? 'Terminal'
+    execSync(`osascript -e 'tell application "${app}" to activate'`)
+  })

package/src/commands/folder-sizes.mjs

@@ -1,8 +1,7 @@
 import { readdirSync, statSync } from 'node:fs'
 import { join, resolve } from 'node:path'
 
-import cosmetic from 'cosmetic'
-import { command as createCommand } from 'termkit'
+import { Color, command as createCommand, Spinner } from 'termkit'
 
 function getDirSize(dirPath) {
   let total = 0
@@ -39,29 +38,35 @@ export const command = createCommand('folder-sizes')
     try {
       entries = readdirSync(root, { withFileTypes: true })
     } catch {
-      console.error(cosmetic.red(`Could not read directory: ${root}`))
+      console.error(Color.red(`Could not read directory: ${root}`))
       process.exit(1)
     }
 
+    const spinner = new Spinner({ text: 'Scanning...' })
+    spinner.start()
+
     const folders = entries
       .filter((e) => e.isDirectory())
       .map((e) => {
+        spinner.message(e.name)
         const size = getDirSize(join(root, e.name))
         return { name: e.name, size }
       })
       .sort((a, b) => b.size - a.size)
 
     if (folders.length === 0) {
-      console.log(cosmetic.faint('No folders found.'))
+      spinner.warn('No folders found.')
       return
     }
 
+    spinner.succeed(`${folders.length} folders`)
+
     const maxName = Math.max(...folders.map((f) => f.name.length))
     const maxSize = Math.max(...folders.map((f) => formatSize(f.size).length))
 
     for (const folder of folders) {
       const name = folder.name.padEnd(maxName)
       const size = formatSize(folder.size).padStart(maxSize)
-      console.log(`  ${cosmetic.cyan(name)}  ${cosmetic.bold(size)}`)
+      console.log(`  ${Color.cyan(name)}  ${Color.bold(size)}`)
     }
   })

package/src/commands/new-expo-project.mjs

@@ -0,0 +1,77 @@
+import { execSync } from 'node:child_process'
+import { cpSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { Color, command as createCommand, log } from 'termkit'
+
+const BOILERPLATE_REPO = 'git@github.com:jayrdeaton/Expo-Boilerplate.git'
+const BOILERPLATE_DIR = join(homedir(), 'Developer', 'Expo-Boilerplate')
+const DEV_DIR = join(homedir(), 'Developer')
+
+function exec(cmd, opts = {}) {
+  console.log(Color.faint(`$ ${cmd}`))
+  execSync(cmd, { stdio: 'inherit', ...opts })
+}
+
+function parseWords(name) {
+  return name
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .split(/[\s\-_]+/)
+    .filter(Boolean)
+}
+
+export const command = createCommand('new-expo-project')
+  .description('Bootstrap a new Expo project from the boilerplate')
+  .option('n', 'name', '<name>', 'Project name')
+  .action(async (options) => {
+    const words = parseWords(options.name)
+    const displayName = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')
+    const slug = words.map((w) => w.toLowerCase()).join('-')
+    const pascal = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('')
+    const lower = words.map((w) => w.toLowerCase()).join('')
+    const dirName = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join('-')
+    const targetDir = join(DEV_DIR, dirName)
+
+    if (existsSync(targetDir)) {
+      log.fail(`Directory already exists: ${targetDir}`)
+      process.exit(1)
+    }
+
+    if (existsSync(BOILERPLATE_DIR)) {
+      log.info('Pulling latest boilerplate...')
+      exec('git pull', { cwd: BOILERPLATE_DIR })
+    } else {
+      log.info('Cloning boilerplate...')
+      exec(`git clone ${BOILERPLATE_REPO} "${BOILERPLATE_DIR}"`)
+    }
+
+    log.info(`Creating ${displayName}...`)
+    cpSync(BOILERPLATE_DIR, targetDir, {
+      recursive: true,
+      filter: (src) => !src.includes('/node_modules/'),
+    })
+
+    rmSync(join(targetDir, '.git'), { recursive: true, force: true })
+
+    const pkgPath = join(targetDir, 'package.json')
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+    pkg.name = slug
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+
+    const appPath = join(targetDir, 'app.json')
+    const app = JSON.parse(readFileSync(appPath, 'utf8'))
+    app.expo.name = displayName
+    app.expo.slug = slug
+    app.expo.scheme = lower
+    app.expo.description = `${displayName} app`
+    app.expo.ios.bundleIdentifier = `com.infinitetoken.${pascal}`
+    app.expo.android.package = `com.infinitetoken.${lower}`
+    writeFileSync(appPath, JSON.stringify(app, null, 2) + '\n')
+
+    exec('git init', { cwd: targetDir })
+    exec('git add -A', { cwd: targetDir })
+    exec('git commit -m "Initial commit"', { cwd: targetDir })
+
+    log.succeed(`${displayName} created at ${targetDir}`)
+  })

package/src/commands/npm-downloads.mjs

@@ -0,0 +1,95 @@
+import { execSync } from 'node:child_process'
+
+import { Color, command as createCommand, Spinner } from 'termkit'
+
+async function fetchJson(url) {
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`HTTP ${res.status}: ${url}`)
+  return res.json()
+}
+
+async function getAllPackages(username) {
+  const packages = []
+  const size = 250
+  let from = 0
+
+  while (true) {
+    const data = await fetchJson(`https://registry.npmjs.org/-/v1/search?text=maintainer:${username}&size=${size}&from=${from}`)
+    packages.push(...data.objects.map((o) => o.package.name))
+    if (packages.length >= data.total || data.objects.length < size) break
+    from += size
+  }
+
+  return packages
+}
+
+async function getDownloads(pkg, period) {
+  try {
+    const data = await fetchJson(`https://api.npmjs.org/downloads/point/${period}/${pkg}`)
+    return data.downloads ?? 0
+  } catch {
+    return 0
+  }
+}
+
+export const command = createCommand('npm-downloads')
+  .description('List all your npm packages sorted by total downloads')
+  .option('u', 'user', '<name>', 'npm username (defaults to npm whoami)')
+  .option('p', 'period', '<period>', 'last-day | last-week | last-month | last-year (default: last-month)')
+  .option('m', 'mtd', null, 'Use month-to-date instead of rolling 30 days')
+  .action(async (options) => {
+    const spinner = new Spinner({ text: 'Resolving username...' })
+    spinner.start()
+
+    let username = options.user
+    if (!username) {
+      try {
+        username = execSync('npm whoami', {
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'ignore']
+        }).trim()
+      } catch {
+        spinner.fail('Could not determine npm username. Use --user <name> or run `npm login`.')
+        process.exit(1)
+      }
+    }
+
+    let period = options.period ?? 'last-month'
+    if (options.mtd) {
+      const now = new Date()
+      const yyyy = now.getFullYear()
+      const mm = String(now.getMonth() + 1).padStart(2, '0')
+      const dd = String(now.getDate()).padStart(2, '0')
+      period = `${yyyy}-${mm}-01:${yyyy}-${mm}-${dd}`
+    }
+
+    spinner.message(`Fetching packages for ${username}...`)
+    const packages = await getAllPackages(username)
+
+    if (packages.length === 0) {
+      spinner.warn(`No packages found for ${username}.`)
+      return
+    }
+
+    spinner.message(`Fetching download counts (${period})...`)
+    const results = await Promise.all(packages.map(async (name) => ({ name, downloads: await getDownloads(name, period) })))
+
+    spinner.succeed(`${packages.length} packages · ${period}`)
+
+    const sorted = results.sort((a, b) => b.downloads - a.downloads)
+    const orgs = [...new Set(sorted.filter((p) => p.name.startsWith('@')).map((p) => p.name.split('/')[0]))]
+    const maxWidth = String(sorted[0]?.downloads ?? 0).length
+
+    console.log(`\n${Color.bold(username)} — ${Color.faint(period)}`)
+    if (orgs.length > 0) console.log(Color.faint(`orgs: ${orgs.join('  ')}`))
+    console.log()
+
+    for (const { name, downloads } of sorted) {
+      const count = String(downloads).padStart(maxWidth)
+      const label = downloads === 0 ? Color.faint(name) : name
+      console.log(`  ${Color.cyan(count)}  ${label}`)
+    }
+
+    const total = sorted.reduce((sum, p) => sum + p.downloads, 0)
+    console.log(Color.faint(`\n${total.toLocaleString()} total downloads across ${sorted.length} packages`))
+  })

package/src/commands/npm-namer.mjs

@@ -0,0 +1,75 @@
+import { Color, command as createCommand, Spinner } from 'termkit'
+
+async function isAvailable(name) {
+  try {
+    const encoded = name.startsWith('@') ? name.replace('/', '%2F') : name
+    const res = await fetch(`https://registry.npmjs.org/${encoded}`, { method: 'HEAD' })
+    return res.status === 404
+  } catch {
+    return null
+  }
+}
+
+function getVariants(name) {
+  const normalized = name.replace(/[-_]/g, ' ').trim()
+  if (!normalized.includes(' ')) return [normalized]
+
+  const nospace = normalized.replace(/ /g, '')
+  const hyphenated = normalized.replace(/ /g, '-')
+  const underscored = normalized.replace(/ /g, '_')
+  return [...new Set([nospace, hyphenated, underscored])]
+}
+
+async function getSynonyms(word) {
+  try {
+    const base = word.replace(/[-_]/g, ' ').trim().split(' ')[0]
+    const res = await fetch(`https://api.datamuse.com/words?ml=${encodeURIComponent(base)}&max=20`)
+    if (!res.ok) return []
+    const data = await res.json()
+    return data.map((w) => w.word).filter((w) => !w.includes(' '))
+  } catch {
+    return []
+  }
+}
+
+export const command = createCommand('npm-namer')
+  .description('Check npm package name availability, including variations')
+  .variable('<name>')
+  .option('s', 'synonyms', null, 'Also check synonyms of the name')
+  .action(async (args) => {
+    const { name, synonyms } = args
+    const spinner = new Spinner({ text: 'Checking availability...' })
+    spinner.start()
+
+    const namesToCheck = new Set(getVariants(name))
+
+    if (synonyms) {
+      spinner.message('Fetching synonyms...')
+      const syns = await getSynonyms(name)
+      for (const syn of syns) {
+        for (const variant of getVariants(syn)) {
+          namesToCheck.add(variant)
+        }
+      }
+      spinner.message(`Checking ${namesToCheck.size} names...`)
+    }
+
+    const results = await Promise.all([...namesToCheck].map(async (n) => ({ name: n, available: await isAvailable(n) })))
+
+    spinner.stop()
+
+    const available = results.filter((r) => r.available === true)
+    const taken = results.filter((r) => r.available === false)
+    const errored = results.filter((r) => r.available === null)
+
+    console.log()
+    for (const { name: n, available: avail } of results) {
+      if (avail === true) console.log(`  ${Color.green('✓')}  ${n}`)
+      else if (avail === false) console.log(`  ${Color.red('✗')}  ${Color.faint(n)}`)
+      else console.log(`  ${Color.yellow('?')}  ${Color.faint(n)}`)
+    }
+
+    const parts = [`${available.length} available`, `${taken.length} taken`]
+    if (errored.length > 0) parts.push(`${errored.length} error`)
+    console.log(`\n${Color.faint(parts.join(' · '))}`)
+  })

package/src/commands/rename-season.mjs

@@ -1,8 +1,7 @@
 import { readdirSync, renameSync, statSync } from 'node:fs'
 import { extname, join } from 'node:path'
 
-import cosmetic from 'cosmetic'
-import { command as createCommand } from 'termkit'
+import { Color, command as createCommand, log } from 'termkit'
 
 export const command = createCommand('rename-season')
   .description('Rename files in a directory to SxEE format for TV library pickup')
@@ -14,7 +13,7 @@ export const command = createCommand('rename-season')
     try {
       files = readdirSync(dir)
     } catch {
-      console.error(cosmetic.red(`Could not read directory: ${dir}`))
+      log.fail(`Could not read directory: ${dir}`)
       process.exit(1)
     }
 
@@ -33,7 +32,7 @@ export const command = createCommand('rename-season')
       const newPath = join(dir, newName)
 
       if (filePath !== newPath) {
-        console.log(`${cosmetic.faint(file)} -> ${cosmetic.cyan(newName)}`)
+        console.log(`${Color.faint(file)} -> ${Color.cyan(newName)}`)
         renameSync(filePath, newPath)
         renamed++
       }
@@ -41,5 +40,5 @@ export const command = createCommand('rename-season')
       counter++
     }
 
-    console.log(cosmetic.bold.green(`\nDone. Renamed ${renamed} files.`))
+    log.succeed(`Renamed ${renamed} files.`)
   })

package/src/commands/repo-status.mjs

@@ -2,15 +2,14 @@ import { execSync } from 'node:child_process'
 import { readdirSync, statSync } from 'node:fs'
 import { join, resolve } from 'node:path'
 
-import cosmetic from 'cosmetic'
-import { command as createCommand } from 'termkit'
+import { Color, command as createCommand, Spinner } from 'termkit'
 
 function getGitStatus(dir) {
   try {
     const out = execSync('git status --porcelain', {
       cwd: dir,
       stdio: ['ignore', 'pipe', 'ignore'],
-      encoding: 'utf8',
+      encoding: 'utf8'
     })
     const lines = out.split('\n').filter(Boolean)
     const dirty = lines.filter((l) => !l.startsWith('??'))
@@ -21,7 +20,7 @@ function getGitStatus(dir) {
       const ahead = execSync('git rev-list --count @{u}..HEAD', {
         cwd: dir,
         stdio: ['ignore', 'pipe', 'ignore'],
-        encoding: 'utf8',
+        encoding: 'utf8'
       }).trim()
       unpushed = parseInt(ahead, 10) || 0
     } catch {
@@ -44,10 +43,13 @@ export const command = createCommand('repo-status')
     try {
       entries = readdirSync(root)
     } catch {
-      console.error(cosmetic.red(`Could not read directory: ${root}`))
+      console.error(Color.red(`Could not read directory: ${root}`))
       process.exit(1)
     }
 
+    const spinner = new Spinner({ text: 'Checking repos...' })
+    spinner.start()
+
     const repos = entries
       .filter((name) => {
         try {
@@ -56,7 +58,10 @@ export const command = createCommand('repo-status')
           return false
         }
       })
-      .map((name) => ({ name, ...getGitStatus(join(root, name)) }))
+      .map((name) => {
+        spinner.message(name)
+        return { name, ...getGitStatus(join(root, name)) }
+      })
       .filter((r) => r.isRepo)
 
     const dirty = repos.filter((r) => r.dirty.length > 0)
@@ -65,30 +70,32 @@ export const command = createCommand('repo-status')
     const clean = repos.filter((r) => r.dirty.length === 0 && r.untracked.length === 0 && r.unpushed === 0)
 
     if (dirty.length === 0 && untracked.length === 0 && unpushed.length === 0) {
-      console.log(cosmetic.green(`All ${clean.length} repos are clean.`))
+      spinner.succeed(`All ${clean.length} repos are clean.`)
       return
     }
 
+    spinner.stop()
+
     if (dirty.length > 0) {
-      console.log(cosmetic.bold.red(`\nDirty (${dirty.length})`))
+      console.log(Color.bold.red(`\nDirty (${dirty.length})`))
       for (const repo of dirty) {
-        console.log(`  ${cosmetic.red(repo.name)}  ${cosmetic.faint(`${repo.dirty.length} change${repo.dirty.length !== 1 ? 's' : ''}`)}`)
+        console.log(`  ${Color.red(repo.name)}  ${Color.faint(`${repo.dirty.length} change${repo.dirty.length !== 1 ? 's' : ''}`)}`)
       }
     }
 
     if (untracked.length > 0) {
-      console.log(cosmetic.bold.yellow(`\nUntracked (${untracked.length})`))
+      console.log(Color.bold.yellow(`\nUntracked (${untracked.length})`))
       for (const repo of untracked) {
-        console.log(`  ${cosmetic.yellow(repo.name)}  ${cosmetic.faint(`${repo.untracked.length} file${repo.untracked.length !== 1 ? 's' : ''}`)}`)
+        console.log(`  ${Color.yellow(repo.name)}  ${Color.faint(`${repo.untracked.length} file${repo.untracked.length !== 1 ? 's' : ''}`)}`)
       }
     }
 
     if (unpushed.length > 0) {
-      console.log(cosmetic.bold.cyan(`\nUnpushed (${unpushed.length})`))
+      console.log(Color.bold.cyan(`\nUnpushed (${unpushed.length})`))
       for (const repo of unpushed) {
-        console.log(`  ${cosmetic.cyan(repo.name)}  ${cosmetic.faint(`${repo.unpushed} commit${repo.unpushed !== 1 ? 's' : ''} ahead`)}`)
+        console.log(`  ${Color.cyan(repo.name)}  ${Color.faint(`${repo.unpushed} commit${repo.unpushed !== 1 ? 's' : ''} ahead`)}`)
       }
     }
 
-    console.log(cosmetic.faint(`\n${clean.length} of ${repos.length} repos clean`))
+    console.log(Color.faint(`\n${clean.length} of ${repos.length} repos clean`))
   })

package/src/commands/update-boilerplate.mjs

@@ -0,0 +1,52 @@
+import { execSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { Color, command as createCommand, log } from 'termkit'
+
+const BOILERPLATE_REPO = 'git@github.com:jayrdeaton/Expo-Boilerplate.git'
+const BOILERPLATE_DIR = join(homedir(), 'Developer', 'Expo-Boilerplate')
+
+function exec(cmd, opts = {}) {
+  console.log(Color.faint(`$ ${cmd}`))
+  execSync(cmd, { stdio: 'inherit', ...opts })
+}
+
+export const command = createCommand('update-boilerplate')
+  .description('Update Expo boilerplate — clones if absent, updates deps, commits, and pushes')
+  .action(async () => {
+    if (existsSync(BOILERPLATE_DIR)) {
+      log.info('Boilerplate found, pulling latest...')
+      exec('git pull', { cwd: BOILERPLATE_DIR })
+    } else {
+      log.info('Cloning boilerplate...')
+      exec(`git clone ${BOILERPLATE_REPO} "${BOILERPLATE_DIR}"`)
+    }
+
+    log.info('Updating dependencies...')
+    exec('jrd update-deps', { cwd: BOILERPLATE_DIR })
+
+    const status = execSync('git status --porcelain', { cwd: BOILERPLATE_DIR }).toString().trim()
+
+    if (!status) {
+      log.succeed('Nothing to commit — boilerplate is already up to date.')
+      return
+    }
+
+    log.info('Running lint fix...')
+    exec('npm run fix', { cwd: BOILERPLATE_DIR })
+
+    log.info('Running type check...')
+    exec('npm run check', { cwd: BOILERPLATE_DIR })
+
+    log.info('Running tests...')
+    exec('npm test', { cwd: BOILERPLATE_DIR })
+
+    log.info('Committing and pushing...')
+    exec('git add -A', { cwd: BOILERPLATE_DIR })
+    exec('git commit -m "Update dependencies"', { cwd: BOILERPLATE_DIR })
+    exec('git push', { cwd: BOILERPLATE_DIR })
+
+    log.succeed('Boilerplate updated.')
+  })