@jayrdeaton/scripts 1.0.0 → 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,8 +1,12 @@
 {
   "name": "@jayrdeaton/scripts",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "private": false,
   "description": "Personal dev scripts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jayrdeaton/Scripts"
+  },
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -13,11 +17,15 @@
     "src"
   ],
   "scripts": {
-    "fix": "eslint --fix",
-    "lint": "eslint"
+    "fix": "npm run lint:fix",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "release:major": "npm version major && git push --follow-tags",
+    "release:minor": "npm version minor && git push --follow-tags",
+    "release:patch": "npm version patch && git push --follow-tags",
+    "preversion": "npm ci && npm run lint"
   },
   "dependencies": {
-    "cosmetic": "latest",
     "termkit": "latest"
   },
   "devDependencies": {
@@ -28,10 +36,10 @@
     "eslint-plugin-simple-import-sort": "^13.0.0",
     "prettier": "^3.8.3"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "engines": {
     "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

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,23 +2,24 @@ import { execSync } from 'node:child_process'
 import { readFileSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-import cosmetic from 'cosmetic'
-import { command as createCommand } from 'termkit'
+import { command as createCommand, Spinner } from 'termkit'
 
 export const command = createCommand('bump-ota')
   .description('Bump otaVersion in src/constants/release.ts and commit')
   .option('f', 'file', '[file]', 'Path to release file (default: src/constants/release.ts)')
   .action(async (options) => {
     const filePath = resolve(process.cwd(), options.file ?? 'src/constants/release.ts')
+    const spinner = new Spinner({ text: 'Checking git status...' })
+    spinner.start()
 
     try {
       const status = execSync('git status --porcelain').toString().trim()
       if (status) {
-        console.error(cosmetic.red('Working directory is not clean. Commit or stash changes first.'))
+        spinner.fail('Working directory is not clean. Commit or stash changes first.')
         process.exit(1)
       }
     } catch (err) {
-      console.error(cosmetic.red(`Failed to check git status: ${err.message}`))
+      spinner.fail(`Failed to check git status: ${err.message}`)
       process.exit(1)
     }
 
@@ -26,7 +27,7 @@ export const command = createCommand('bump-ota')
     try {
       source = readFileSync(filePath, 'utf8')
     } catch {
-      console.error(cosmetic.red(`Could not read file: ${filePath}`))
+      spinner.fail(`Could not read file: ${filePath}`)
       process.exit(1)
     }
 
@@ -34,7 +35,7 @@ export const command = createCommand('bump-ota')
     const match = source.match(pattern)
 
     if (!match) {
-      console.error(cosmetic.red(`Could not find otaVersion in ${filePath}`))
+      spinner.fail(`Could not find otaVersion in ${filePath}`)
       process.exit(1)
     }
 
@@ -43,13 +44,14 @@ export const command = createCommand('bump-ota')
 
     writeFileSync(filePath, source.replace(pattern, `$1${next}`))
 
+    spinner.message('Committing...')
     try {
       execSync(`git add ${filePath}`)
       execSync(`git commit -m "otaVersion ${current} -> ${next}"`)
     } catch (err) {
-      console.error(cosmetic.red(`Auto-commit failed: ${err.message}`))
+      spinner.fail(`Auto-commit failed: ${err.message}`)
       process.exit(1)
     }
 
-    console.log(cosmetic.bold.green(`otaVersion bumped: ${current} -> ${next}`))
+    spinner.succeed(`otaVersion bumped: ${current} -> ${next}`)
   })

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' : ''}`)
+  })