@jayrdeaton/scripts 1.0.2 → 1.1.0

package/README.md

@@ -10,6 +10,36 @@ npm install -g @jayrdeaton/scripts
 
 ## Commands
 
+### `jrd base64`
+
+Encode or decode base64 strings and files.
+
+```
+jrd base64 encode <value> [options]
+jrd base64 decode <value> [options]
+
+Options:
+  -f, --file   Treat value as a file path
+  -c, --copy   Copy result to clipboard
+```
+
+---
+
+### `jrd binary`
+
+Encode a file to a binary string, or restore a binary string back to its original file.
+
+```
+jrd binary encode <file> [options]
+jrd binary decode <file> <destination>
+
+Options (encode):
+  -c, --copy           Copy result to clipboard
+  -o, --output <dest>  Write result to a file
+```
+
+---
+
 ### `jrd bump-ota`
 
 Bumps `otaVersion` in `src/constants/release.ts` and auto-commits the change. Requires a clean working directory.
@@ -23,6 +53,57 @@ Options:
 
 ---
 
+### `jrd check-domains`
+
+Check domain availability via RDAP using a wildcard pattern where `?` matches any letter. Supports `.com`, `.net`, `.org`, and `.io`.
+
+```
+jrd check-domains <pattern> [options]
+
+Options:
+  -c, --concurrency <n>   Concurrent requests (default: 5)
+  -o, --output <file>     Write available domains to a file
+```
+
+Example: `jrd check-domains ??fu.com`
+
+---
+
+### `jrd clean-builds`
+
+Delete build artifacts (`build`, `dist`, `ios`, `android`) across one or more repos. Dry run by default.
+
+```
+jrd clean-builds [dir...] [options]
+
+Options:
+  -m, --modules   Also delete node_modules
+  -D, --delete    Actually delete (default is dry run)
+```
+
+---
+
+### `jrd clean-junk`
+
+Delete files and directories matching given criteria.
+
+```
+jrd clean-junk [dir] [options]
+
+Options:
+  -i, --includes <str>    Delete items whose name includes this string
+  -e, --excludes <str>    Delete items whose name excludes this string
+      --extension <str>   Delete files with this extension
+  -s, --size <mb>         Delete items under this size in MB
+  -r, --recursive         Scan directories recursively
+  -f, --force             Skip confirmation
+  -v, --verbose           Show matched items before deleting
+```
+
+Example: `jrd clean-junk --includes .DS_Store -r`
+
+---
+
 ### `jrd code-count`
 
 Count lines of code by file extension across one or more paths.
@@ -37,6 +118,18 @@ Options:
 
 ---
 
+### `jrd focus`
+
+Bring an application to the front using AppleScript.
+
+```
+jrd focus [app]
+```
+
+Default app is `Terminal`.
+
+---
+
 ### `jrd folder-sizes`
 
 List all subdirectories sorted by size, largest first.
@@ -47,6 +140,34 @@ jrd folder-sizes [dir]
 
 ---
 
+### `jrd npm-downloads`
+
+List all your npm packages sorted by total downloads.
+
+```
+jrd npm-downloads [options]
+
+Options:
+  -u, --user <name>      npm username (defaults to npm whoami)
+  -p, --period <period>  last-day | last-week | last-month | last-year (default: last-month)
+  -m, --mtd              Use month-to-date instead of rolling 30 days
+```
+
+---
+
+### `jrd npm-namer`
+
+Check npm package name availability. Automatically checks nospace, hyphenated, and underscored variants.
+
+```
+jrd npm-namer <name> [options]
+
+Options:
+  -s, --synonyms   Also check synonyms of the name
+```
+
+---
+
 ### `jrd rename-season`
 
 Rename files in a directory to `SxEE` format for TV library pickup (e.g. `1x01.mkv`, `1x02.mkv`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jayrdeaton/scripts",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "private": false,
   "description": "Personal dev scripts",
   "repository": {
@@ -26,9 +26,7 @@
     "preversion": "npm ci && npm run lint"
   },
   "dependencies": {
-    "cosmetic": "latest",
-    "termkit": "latest",
-    "termpulse": "^1.1.3"
+    "termkit": "latest"
   },
   "devDependencies": {
     "eslint": "^10.4.1",

package/src/commands/base64.mjs

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { execSync } from 'node:child_process'
+
+import { Color, command as createCommand } from 'termkit'
+
+function resolveInput(value, file) {
+  if (file) {
+    if (!existsSync(value)) throw new Error(`${value} not found`)
+    return readFileSync(value)
+  }
+  return value
+}
+
+function output(result, copy) {
+  if (copy) {
+    execSync('pbcopy', { input: result })
+    console.log(`${Color.green('Success:')} Copied to clipboard`)
+  } else {
+    console.log(result)
+  }
+}
+
+export const command = createCommand('base64')
+  .description('Encode or decode base64')
+  .commands([
+    createCommand('encode')
+      .description('Encode a string or file to base64')
+      .variable('<value>')
+      .option('f', 'file', null, 'treat value as a file path')
+      .option('c', 'copy', null, 'copy result to clipboard')
+      .action(({ value, file, copy }) => {
+        const input = resolveInput(value, file)
+        const result = Buffer.from(input).toString('base64')
+        output(result, copy)
+      }),
+
+    createCommand('decode')
+      .description('Decode a base64 string')
+      .variable('<value>')
+      .option('c', 'copy', null, 'copy result to clipboard')
+      .action(({ value, copy }) => {
+        const result = Buffer.from(value, 'base64').toString('utf8')
+        output(result, copy)
+      }),
+  ])

package/src/commands/binary.mjs

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { execSync } from 'node:child_process'
+
+import { Color, command as createCommand } from 'termkit'
+
+export const command = createCommand('binary')
+  .description('Encode or decode binary strings')
+  .commands([
+    createCommand('encode')
+      .description('Encode a file to a binary string')
+      .variable('<file>')
+      .option('c', 'copy', null, 'copy result to clipboard')
+      .option('o', 'output', '<dest>', 'write result to a file')
+      .action(({ file, copy, output }) => {
+        if (!existsSync(file)) throw new Error(`${file} not found`)
+        const result = JSON.stringify(readFileSync(file, 'binary'))
+        if (copy) {
+          execSync('pbcopy', { input: result })
+          console.log(`${Color.green('Success:')} Copied binary string to clipboard`)
+        } else if (output) {
+          writeFileSync(output, result)
+          console.log(`${Color.green('Success:')} Wrote binary string to ${output}`)
+        } else {
+          console.log(result)
+        }
+      }),
+
+    createCommand('decode')
+      .description('Restore a binary string file back to its original format')
+      .variable('<file>')
+      .variable('<destination>')
+      .action(({ file, destination }) => {
+        if (!existsSync(file)) throw new Error(`${file} not found`)
+        const buf = Buffer.from(JSON.parse(readFileSync(file, 'utf8')), 'binary')
+        writeFileSync(destination, buf)
+        console.log(`${Color.green('Success:')} Restored ${file} to ${destination}`)
+      }),
+  ])

package/src/commands/bump-ota.mjs

@@ -2,8 +2,7 @@ import { execSync } from 'node:child_process'
 import { readFileSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-import { command as createCommand } from 'termkit'
-import { Spinner } from 'termpulse'
+import { command as createCommand, Spinner } from 'termkit'
 
 export const command = createCommand('bump-ota')
   .description('Bump otaVersion in src/constants/release.ts and commit')

package/src/commands/check-domains.mjs

@@ -0,0 +1,102 @@
+import { writeFile } from 'node:fs/promises'
+
+import { Color, command as createCommand, Spinner } from 'termkit'
+
+const RDAP = {
+  com: 'https://rdap.verisign.com/com/v1',
+  net: 'https://rdap.verisign.com/net/v1',
+  org: 'https://rdap.publicinterestregistry.org/rdap/org/v1',
+  io: 'https://rdap.nic.io/v1'
+}
+
+const ALPHA = 'abcdefghijklmnopqrstuvwxyz'.split('')
+
+function expandPattern(pattern) {
+  const dot = pattern.lastIndexOf('.')
+  if (dot === -1) throw new Error(`Pattern must include a TLD, e.g. ??fu.com`)
+  const namePart = pattern.slice(0, dot).toLowerCase()
+  const tld = pattern.slice(dot + 1).toLowerCase()
+  if (!RDAP[tld]) throw new Error(`.${tld} is not supported — supported TLDs: ${Object.keys(RDAP).join(', ')}`)
+
+  function expand(s) {
+    const i = s.indexOf('?')
+    if (i === -1) return [s]
+    return ALPHA.flatMap((c) => expand(s.slice(0, i) + c + s.slice(i + 1)))
+  }
+
+  return expand(namePart).map((n) => `${n}.${tld}`)
+}
+
+async function isAvailable(domain) {
+  const tld = domain.slice(domain.lastIndexOf('.') + 1)
+  const res = await fetch(`${RDAP[tld]}/domain/${domain}`, { signal: AbortSignal.timeout(10_000) })
+  if (res.status === 404) return true
+  if (res.ok) return false
+  throw new Error(`HTTP ${res.status}`)
+}
+
+async function withConcurrency(items, limit, fn) {
+  let i = 0
+  async function worker() {
+    while (i < items.length) {
+      const item = items[i++]
+      await fn(item)
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker))
+}
+
+export const command = createCommand('check-domains')
+  .description('Check domain availability via RDAP for a wildcard pattern (? = any letter)')
+  .variable('[pattern]')
+  .option('c', 'concurrency', '<n>', 'Concurrent requests (default: 5)')
+  .option('o', 'output', '<file>', 'Write available domains to a file')
+  .action(async (args) => {
+    const pattern = args.pattern
+    if (!pattern) {
+      console.error(Color.red('Usage: jrd check-domains <pattern>  e.g. ??fu.com or ???.io'))
+      process.exit(1)
+    }
+
+    const concurrency = Math.max(1, parseInt(args.concurrency ?? '5', 10))
+
+    let domains
+    try {
+      domains = expandPattern(pattern)
+    } catch (err) {
+      console.error(Color.red(err.message))
+      process.exit(1)
+    }
+
+    const available = []
+    let checked = 0
+    let errors = 0
+
+    const spinner = new Spinner({ text: `0/${domains.length}` })
+    spinner.start()
+
+    await withConcurrency(domains, concurrency, async (domain) => {
+      try {
+        const ok = await isAvailable(domain)
+        checked++
+        spinner.message(`${checked}/${domains.length}  ${Color.faint(domain)}`)
+        if (ok) {
+          available.push(domain)
+          spinner.stop()
+          console.log(`  ${Color.green(domain)}`)
+          spinner.start()
+          spinner.message(`${checked}/${domains.length}  ${Color.faint(domain)}`)
+        }
+      } catch {
+        errors++
+        checked++
+      }
+    })
+
+    if (args.output && available.length > 0) {
+      await writeFile(args.output, available.join('\n') + '\n')
+      spinner.succeed(`${available.length} available · saved to ${args.output}` + (errors > 0 ? Color.faint(`  (${errors} errors)`) : ''))
+    } else {
+      spinner.succeed(`${available.length} available of ${domains.length}` + (errors > 0 ? Color.faint(`  (${errors} errors)`) : ''))
+    }
+  })

package/src/commands/clean-builds.mjs

@@ -0,0 +1,129 @@
+import { existsSync, readdirSync, rmSync, statSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+import { Color, command as createCommand, Spinner } from 'termkit'
+
+const BUILD_TARGETS = ['build', 'dist', 'ios', 'android']
+
+function getDirSize(dirPath) {
+  let total = 0
+  try {
+    for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+      const full = join(dirPath, entry.name)
+      if (entry.isSymbolicLink()) continue
+      if (entry.isDirectory()) {
+        total += getDirSize(full)
+      } else {
+        try {
+          total += statSync(full).size
+        } catch {}
+      }
+    }
+  } catch {}
+  return total
+}
+
+function formatSize(bytes) {
+  if (bytes >= 1_073_741_824) return `${(bytes / 1_073_741_824).toFixed(1)} GB`
+  if (bytes >= 1_048_576) return `${(bytes / 1_048_576).toFixed(1)} MB`
+  if (bytes >= 1_024) return `${(bytes / 1_024).toFixed(1)} KB`
+  return `${bytes} B`
+}
+
+function findTargets(projectDir, targets) {
+  return targets
+    .map((t) => join(projectDir, t))
+    .filter((p) => {
+      try {
+        return statSync(p).isDirectory()
+      } catch {
+        return false
+      }
+    })
+}
+
+function resolveProjects(dirs) {
+  const projects = []
+  for (const dir of dirs) {
+    const root = resolve(dir)
+    if (existsSync(join(root, 'package.json'))) {
+      projects.push({ root, path: root })
+    } else {
+      let entries
+      try {
+        entries = readdirSync(root, { withFileTypes: true })
+      } catch {
+        console.error(Color.red(`Could not read directory: ${root}`))
+        process.exit(1)
+      }
+      for (const e of entries) {
+        if (e.isDirectory()) projects.push({ root, path: join(root, e.name) })
+      }
+    }
+  }
+  return projects
+}
+
+export const command = createCommand('clean-builds')
+  .description('Delete build artifacts across repos — dry run by default')
+  .variable('[dir...]')
+  .option('m', 'modules', null, 'Also delete node_modules')
+  .option('D', 'delete', null, 'Actually delete (default is dry run)')
+  .action(async (options) => {
+    const dirs = options.dir?.length ? options.dir : ['.']
+    const targets = [...BUILD_TARGETS]
+    if (options.modules) targets.push('node_modules')
+
+    const projects = resolveProjects(dirs)
+
+    const spinner = new Spinner({ text: 'Scanning...' })
+    spinner.start()
+
+    const toDelete = []
+    for (const { root, path: projectDir } of projects) {
+      spinner.message(projectDir.split('/').at(-1))
+      for (const targetPath of findTargets(projectDir, targets)) {
+        const size = getDirSize(targetPath)
+        toDelete.push({ root, path: targetPath, size })
+      }
+    }
+
+    spinner.stop()
+
+    if (toDelete.length === 0) {
+      console.log(Color.green('Nothing to clean.'))
+      return
+    }
+
+    const totalSize = toDelete.reduce((sum, f) => sum + f.size, 0)
+
+    if (!options.delete) {
+      console.log(Color.bold.yellow('\nDry run — pass --delete to remove:\n'))
+      for (const { root, path, size } of toDelete) {
+        const rel = path.replace(root + '/', '')
+        console.log(`  ${Color.red(rel)}  ${Color.faint(formatSize(size))}`)
+      }
+      console.log(Color.faint(`\n${toDelete.length} folder${toDelete.length !== 1 ? 's' : ''}  ${formatSize(totalSize)} total`))
+      return
+    }
+
+    const deleteSpinner = new Spinner({ text: 'Deleting...' })
+    deleteSpinner.start()
+
+    let deleted = 0
+    let freed = 0
+    for (const { path, size } of toDelete) {
+      deleteSpinner.message(path.split('/').slice(-2).join('/'))
+      try {
+        rmSync(path, { recursive: true, force: true })
+        deleted++
+        freed += size
+      } catch (err) {
+        deleteSpinner.stop()
+        console.error(Color.red(`  Failed: ${path} — ${err.message}`))
+        deleteSpinner.start()
+      }
+    }
+
+    deleteSpinner.succeed(`Deleted ${deleted} folder${deleted !== 1 ? 's' : ''},  ${formatSize(freed)} freed`)
+  })

package/src/commands/clean-junk.mjs

@@ -0,0 +1,123 @@
+import { extname, basename } from 'node:path'
+import { readdirSync, rmSync, statSync } from 'node:fs'
+import { createInterface } from 'node:readline'
+import { join, resolve } from 'node:path'
+
+import { Color, command as createCommand, Spinner } from 'termkit'
+
+function prompt(question) {
+  return new Promise((res) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout })
+    rl.question(question, (answer) => {
+      rl.close()
+      res(answer)
+    })
+  })
+}
+
+function getItems(dir, recursive) {
+  const items = []
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name)
+      items.push(full)
+      if (recursive && entry.isDirectory()) items.push(...getItems(full, recursive))
+    }
+  } catch {}
+  return items
+}
+
+function getItemSize(itemPath) {
+  let total = 0
+  try {
+    const stat = statSync(itemPath)
+    if (!stat.isDirectory()) return stat.size
+    for (const entry of readdirSync(itemPath, { withFileTypes: true })) {
+      const full = join(itemPath, entry.name)
+      if (entry.isSymbolicLink()) continue
+      total += entry.isDirectory() ? getItemSize(full) : statSync(full).size
+    }
+  } catch {}
+  return total
+}
+
+export const command = createCommand('clean-junk')
+  .description('Delete files and directories matching given criteria')
+  .variable('[dir]')
+  .option('i', 'includes', '<str>', 'Delete items whose name includes this string')
+  .option('e', 'excludes', '<str>', 'Delete items whose name excludes this string')
+  .option(null, 'extension', '<str>', 'Delete files with this extension')
+  .option('s', 'size', '<mb>', 'Delete items under this size in MB')
+  .option('r', 'recursive', null, 'Scan directories recursively')
+  .option('f', 'force', null, 'Skip confirmation')
+  .option('v', 'verbose', null, 'Show matched items before deleting')
+  .action(async (options) => {
+    let { extension, force, verbose } = options
+    const dir = resolve(options.dir ?? '.')
+    const { includes, excludes, recursive, size } = options
+
+    if (extension && !extension.startsWith('.')) extension = `.${extension}`
+
+    if (!includes && !excludes && !extension && !size) {
+      console.error(Color.red('Requires at least one filter: --includes, --excludes, --extension, or --size'))
+      process.exit(1)
+    }
+
+    const spinner = new Spinner({ text: 'Scanning...' })
+    spinner.start()
+    const items = getItems(dir, recursive)
+    spinner.stop()
+
+    const sizeBytes = size ? size * 1_048_576 : null
+    const targets = []
+
+    const filterSpinner = new Spinner({ text: 'Filtering...' })
+    filterSpinner.start()
+
+    for (const item of items) {
+      const name = basename(item)
+      let match = true
+      if (includes && !name.includes(includes)) match = false
+      if (excludes && name.includes(excludes)) match = false
+      if (extension && extname(item) !== extension) match = false
+      if (sizeBytes !== null && getItemSize(item) > sizeBytes) match = false
+      if (match) targets.push(item)
+    }
+
+    filterSpinner.stop()
+
+    if (targets.length === 0) {
+      console.log(Color.green('No junk items found.'))
+      return
+    }
+
+    if (verbose) {
+      for (const item of targets) console.log(`  ${item}`)
+    }
+
+    if (!force) {
+      const answer = await prompt(`Delete ${targets.length} item${targets.length !== 1 ? 's' : ''}? (Y/n) `)
+      if (answer.toLowerCase() !== 'y') {
+        console.log('Aborted.')
+        return
+      }
+    }
+
+    const deleteSpinner = new Spinner({ text: 'Deleting...' })
+    deleteSpinner.start()
+
+    let deleted = 0
+    for (const item of targets) {
+      deleteSpinner.message(basename(item))
+      try {
+        rmSync(item, { recursive: true, force: true })
+        deleted++
+      } catch (err) {
+        deleteSpinner.stop()
+        console.error(Color.red(`  Failed: ${item} — ${err.message}`))
+        deleteSpinner.start()
+      }
+    }
+
+    deleteSpinner.succeed(`Deleted ${deleted} item${deleted !== 1 ? 's' : ''}`)
+  })

package/src/commands/code-count.mjs

@@ -1,9 +1,7 @@
 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 { Spinner } from 'termpulse'
+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'])
 
@@ -79,6 +77,6 @@ export const command = createCommand('code-count')
     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]))}`)
     }
   })

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,9 +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 { Spinner } from 'termpulse'
+import { Color, command as createCommand, Spinner } from 'termkit'
 
 function getDirSize(dirPath) {
   let total = 0
@@ -40,7 +38,7 @@ 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)
     }
 
@@ -69,6 +67,6 @@ export const command = createCommand('folder-sizes')
     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

@@ -1,8 +1,6 @@
 import { execSync } from 'node:child_process'
 
-import cosmetic from 'cosmetic'
-import { command as createCommand } from 'termkit'
-import { Spinner } from 'termpulse'
+import { Color, command as createCommand, Spinner } from 'termkit'
 
 async function fetchJson(url) {
   const res = await fetch(url)
@@ -82,16 +80,16 @@ export const command = createCommand('npm-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${cosmetic.bold(username)} — ${cosmetic.faint(period)}`)
-    if (orgs.length > 0) console.log(cosmetic.faint(`orgs: ${orgs.join('  ')}`))
+    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 ? cosmetic.faint(name) : name
-      console.log(`  ${cosmetic.cyan(count)}  ${label}`)
+      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(cosmetic.faint(`\n${total.toLocaleString()} total downloads across ${sorted.length} packages`))
+    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,9 +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 { log } from 'termpulse'
+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')
@@ -34,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++
       }

package/src/commands/repo-status.mjs

@@ -2,9 +2,7 @@ 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 { Spinner } from 'termpulse'
+import { Color, command as createCommand, Spinner } from 'termkit'
 
 function getGitStatus(dir) {
   try {
@@ -45,7 +43,7 @@ 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)
     }
 
@@ -79,25 +77,25 @@ export const command = createCommand('repo-status')
     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.')
+  })

package/src/commands/update-deps.mjs

@@ -2,12 +2,10 @@ import { execSync } from 'node:child_process'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-import cosmetic from 'cosmetic'
-import { command as createCommand } from 'termkit'
-import { log } from 'termpulse'
+import { Color, command as createCommand, log } from 'termkit'
 
 function exec(cmd) {
-  console.log(cosmetic.faint(`$ ${cmd}`))
+  console.log(Color.faint(`$ ${cmd}`))
   execSync(cmd, { stdio: 'inherit' })
 }
 
@@ -52,5 +50,8 @@ export const command = createCommand('update-deps')
       exec(`npx expo install --fix${options.legacy ? ' -- --legacy-peer-deps' : ''}`)
     }
 
+    log.info('Auditing and fixing vulnerabilities...')
+    exec('npm audit --fix')
+
     log.succeed('Done.')
   })