@jayrdeaton/scripts 1.0.0

package/README.md

@@ -0,0 +1,85 @@
+# @jayrdeaton/scripts
+
+Personal dev CLI. Invoked as `jrd`.
+
+## Install
+
+```sh
+npm install -g @jayrdeaton/scripts
+```
+
+## Commands
+
+### `jrd bump-ota`
+
+Bumps `otaVersion` in `src/constants/release.ts` and auto-commits the change. Requires a clean working directory.
+
+```
+jrd bump-ota [options]
+
+Options:
+  -f, --file <file>   Path to release file (default: src/constants/release.ts)
+```
+
+---
+
+### `jrd code-count`
+
+Count lines of code by file extension across one or more paths.
+
+```
+jrd code-count [paths...] [options]
+
+Options:
+  -i, --ignore <types...>   Ignore files or file types (e.g. .json)
+  -r, --recursive           Scan folders recursively
+```
+
+---
+
+### `jrd folder-sizes`
+
+List all subdirectories sorted by size, largest first.
+
+```
+jrd folder-sizes [dir]
+```
+
+---
+
+### `jrd rename-season`
+
+Rename files in a directory to `SxEE` format for TV library pickup (e.g. `1x01.mkv`, `1x02.mkv`).
+
+```
+jrd rename-season <season> [dir]
+```
+
+---
+
+### `jrd repo-status`
+
+Scan a directory of git repos and report which ones have dirty files, untracked files, or unpushed commits.
+
+```
+jrd repo-status [dir]
+```
+
+---
+
+### `jrd update-deps`
+
+Update all npm dependencies to `@latest`. Automatically runs `npx expo install --fix` if the project uses Expo.
+
+```
+jrd update-deps [options]
+
+Options:
+  -d, --dev      Only update devDependencies
+  -p, --prod     Only update dependencies
+  -l, --legacy   Pass --legacy-peer-deps to npm install
+```
+
+## Requirements
+
+Node >= 20

package/bin/cli.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { readdirSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { command, parse } from 'termkit'
+
+const __dir = dirname(fileURLToPath(import.meta.url))
+const commandsDir = resolve(__dir, '../src/commands')
+
+// Must be created first so termkit registers this as the root command
+const program = command('jrd').description('Personal dev scripts')
+
+const files = readdirSync(commandsDir).filter((f) => f.endsWith('.mjs'))
+const mods = await Promise.all(files.map((f) => import(`../src/commands/${f}`)))
+
+program.commands(mods.map((m) => m.command))
+
+try {
+  await parse(process.argv)
+} catch (err) {
+  console.error(err.message)
+  process.exit(1)
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@jayrdeaton/scripts",
+  "version": "1.0.0",
+  "private": false,
+  "description": "Personal dev scripts",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "jrd": "./bin/cli.mjs"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "fix": "eslint --fix",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "cosmetic": "latest",
+    "termkit": "latest"
+  },
+  "devDependencies": {
+    "eslint": "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-package-json": "^1.3.0",
+    "eslint-plugin-prettier": "^5.5.6",
+    "eslint-plugin-simple-import-sort": "^13.0.0",
+    "prettier": "^3.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/commands/bump-ota.mjs

@@ -0,0 +1,55 @@
+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'
+
+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')
+
+    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.'))
+        process.exit(1)
+      }
+    } catch (err) {
+      console.error(cosmetic.red(`Failed to check git status: ${err.message}`))
+      process.exit(1)
+    }
+
+    let source
+    try {
+      source = readFileSync(filePath, 'utf8')
+    } catch {
+      console.error(cosmetic.red(`Could not read file: ${filePath}`))
+      process.exit(1)
+    }
+
+    const pattern = /(otaVersion:\s*)(\d+)/
+    const match = source.match(pattern)
+
+    if (!match) {
+      console.error(cosmetic.red(`Could not find otaVersion in ${filePath}`))
+      process.exit(1)
+    }
+
+    const current = parseInt(match[2], 10)
+    const next = current + 1
+
+    writeFileSync(filePath, source.replace(pattern, `$1${next}`))
+
+    try {
+      execSync(`git add ${filePath}`)
+      execSync(`git commit -m "otaVersion ${current} -> ${next}"`)
+    } catch (err) {
+      console.error(cosmetic.red(`Auto-commit failed: ${err.message}`))
+      process.exit(1)
+    }
+
+    console.log(cosmetic.bold.green(`otaVersion bumped: ${current} -> ${next}`))
+  })

package/src/commands/code-count.mjs

@@ -0,0 +1,87 @@
+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'
+
+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',
+])
+
+function getFiles(base, { ignore = [], recursive = false } = {}) {
+  try {
+    base = resolve(base)
+    if (!lstatSync(base).isDirectory()) {
+      return existsSync(base) ? [base] : []
+    }
+    const paths = []
+    for (const item of readdirSync(base)) {
+      const ext = extname(item)
+      if (SKIP.has(item) || ignore.includes(item) || ignore.includes(`*${ext}`)) continue
+      const full = join(base, item)
+      const isDir = lstatSync(full).isDirectory()
+      if (recursive && isDir) {
+        paths.push(...getFiles(full, { ignore, recursive }))
+      } else if (!isDir && WHITELIST.has(ext)) {
+        paths.push(full)
+      }
+    }
+    return paths
+  } catch (err) {
+    console.log(`error reading ${base}: ${err.message}`)
+    return []
+  }
+}
+
+function countLines(path) {
+  return new Promise((res) => {
+    let count = 0
+    createReadStream(path)
+      .on('data', (chunk) => {
+        for (let i = 0; i < chunk.length; i++) if (chunk[i] === 10) count++
+      })
+      .on('error', () => res(0))
+      .on('end', () => res(count))
+  })
+}
+
+function commaString(n) {
+  return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',')
+}
+
+export const command = createCommand('code-count')
+  .description('Count lines of code by file type')
+  .variable('[paths...]')
+  .option('i', 'ignore', '[types...]', 'ignore files or file types')
+  .option('r', 'recursive', null, 'scan folders recursively')
+  .action(async (args) => {
+    let { ignore, paths, recursive } = args
+    if (!paths || paths.length === 0) paths = ['.']
+    if (!ignore) ignore = []
+    ignore = ignore.reduce((a, i) => (a.includes(`*${extname(i)}`) ? a : [...a, `*${extname(i)}`]), [])
+
+    const allPaths = paths.flatMap((p) => getFiles(p, { ignore, recursive }))
+
+    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`)
+      totals[ext] = (totals[ext] ?? 0) + (await countLines(path))
+    }
+    if (process.stdout.clearLine) process.stdout.clearLine(0)
+
+    for (const key of Object.keys(totals).sort()) {
+      console.log(`${key}: ${cosmetic.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/folder-sizes.mjs

@@ -0,0 +1,67 @@
+import { readdirSync, statSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+import cosmetic from 'cosmetic'
+import { command as createCommand } from 'termkit'
+
+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`
+}
+
+export const command = createCommand('folder-sizes')
+  .description('List folders sorted by size, largest first')
+  .variable('[dir]')
+  .action(async (args) => {
+    const root = resolve(args.dir ?? '.')
+
+    let entries
+    try {
+      entries = readdirSync(root, { withFileTypes: true })
+    } catch {
+      console.error(cosmetic.red(`Could not read directory: ${root}`))
+      process.exit(1)
+    }
+
+    const folders = entries
+      .filter((e) => e.isDirectory())
+      .map((e) => {
+        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.'))
+      return
+    }
+
+    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)}`)
+    }
+  })

package/src/commands/rename-season.mjs

@@ -0,0 +1,45 @@
+import { readdirSync, renameSync, statSync } from 'node:fs'
+import { extname, join } from 'node:path'
+
+import cosmetic from 'cosmetic'
+import { command as createCommand } from 'termkit'
+
+export const command = createCommand('rename-season')
+  .description('Rename files in a directory to SxEE format for TV library pickup')
+  .variable('<season> [dir]')
+  .action(async (args) => {
+    const { season, dir = '.' } = args
+
+    let files
+    try {
+      files = readdirSync(dir)
+    } catch {
+      console.error(cosmetic.red(`Could not read directory: ${dir}`))
+      process.exit(1)
+    }
+
+    let counter = 1
+    let renamed = 0
+
+    for (const file of files) {
+      if (file.startsWith('.')) continue
+
+      const filePath = join(dir, file)
+      if (!statSync(filePath).isFile()) continue
+
+      const ext = extname(file)
+      const episode = counter.toString().padStart(2, '0')
+      const newName = `${season}x${episode}${ext}`
+      const newPath = join(dir, newName)
+
+      if (filePath !== newPath) {
+        console.log(`${cosmetic.faint(file)} -> ${cosmetic.cyan(newName)}`)
+        renameSync(filePath, newPath)
+        renamed++
+      }
+
+      counter++
+    }
+
+    console.log(cosmetic.bold.green(`\nDone. Renamed ${renamed} files.`))
+  })

package/src/commands/repo-status.mjs

@@ -0,0 +1,94 @@
+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'
+
+function getGitStatus(dir) {
+  try {
+    const out = execSync('git status --porcelain', {
+      cwd: dir,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      encoding: 'utf8',
+    })
+    const lines = out.split('\n').filter(Boolean)
+    const dirty = lines.filter((l) => !l.startsWith('??'))
+    const untracked = lines.filter((l) => l.startsWith('??'))
+
+    let unpushed = 0
+    try {
+      const ahead = execSync('git rev-list --count @{u}..HEAD', {
+        cwd: dir,
+        stdio: ['ignore', 'pipe', 'ignore'],
+        encoding: 'utf8',
+      }).trim()
+      unpushed = parseInt(ahead, 10) || 0
+    } catch {
+      // no upstream configured
+    }
+
+    return { isRepo: true, dirty, untracked, unpushed }
+  } catch {
+    return { isRepo: false }
+  }
+}
+
+export const command = createCommand('repo-status')
+  .description('Report dirty and untracked files across repos in a directory')
+  .variable('[dir]')
+  .action(async (args) => {
+    const root = resolve(args.dir ?? '.')
+
+    let entries
+    try {
+      entries = readdirSync(root)
+    } catch {
+      console.error(cosmetic.red(`Could not read directory: ${root}`))
+      process.exit(1)
+    }
+
+    const repos = entries
+      .filter((name) => {
+        try {
+          return statSync(join(root, name)).isDirectory()
+        } catch {
+          return false
+        }
+      })
+      .map((name) => ({ name, ...getGitStatus(join(root, name)) }))
+      .filter((r) => r.isRepo)
+
+    const dirty = repos.filter((r) => r.dirty.length > 0)
+    const untracked = repos.filter((r) => r.untracked.length > 0)
+    const unpushed = repos.filter((r) => r.unpushed > 0)
+    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.`))
+      return
+    }
+
+    if (dirty.length > 0) {
+      console.log(cosmetic.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' : ''}`)}`)
+      }
+    }
+
+    if (untracked.length > 0) {
+      console.log(cosmetic.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' : ''}`)}`)
+      }
+    }
+
+    if (unpushed.length > 0) {
+      console.log(cosmetic.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(cosmetic.faint(`\n${clean.length} of ${repos.length} repos clean`))
+  })

package/src/commands/update-deps.mjs

@@ -0,0 +1,55 @@
+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'
+
+function exec(cmd) {
+  console.log(cosmetic.faint(`$ ${cmd}`))
+  execSync(cmd, { stdio: 'inherit' })
+}
+
+function latestPackages(deps = {}) {
+  return Object.keys(deps).map((name) => `${name}@latest`)
+}
+
+export const command = createCommand('update-deps')
+  .description('Update all npm deps to @latest, then run expo install --fix if applicable')
+  .option('d', 'dev', null, 'Only update devDependencies')
+  .option('p', 'prod', null, 'Only update dependencies')
+  .option('l', 'legacy', null, 'Pass --legacy-peer-deps to npm install')
+  .action(async (options) => {
+    const pkgPath = resolve(process.cwd(), 'package.json')
+    let pkg
+
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+    } catch {
+      console.error(cosmetic.red('No package.json found in current directory.'))
+      process.exit(1)
+    }
+
+    const prodDeps = latestPackages(pkg.dependencies)
+    const devDeps = latestPackages(pkg.devDependencies)
+    const legacyFlag = options.legacy ? ' --legacy-peer-deps' : ''
+
+    if (!options.dev && prodDeps.length) {
+      console.log(cosmetic.bold.cyan('\nUpdating dependencies...'))
+      exec(`npm install${legacyFlag} ${prodDeps.join(' ')}`)
+    }
+
+    if (!options.prod && devDeps.length) {
+      console.log(cosmetic.bold.cyan('\nUpdating devDependencies...'))
+      exec(`npm install --save-dev${legacyFlag} ${devDeps.join(' ')}`)
+    }
+
+    const hasExpo = pkg.dependencies?.expo !== undefined || pkg.devDependencies?.expo !== undefined
+
+    if (hasExpo) {
+      console.log(cosmetic.bold.cyan('\nFixing Expo managed versions...'))
+      exec(`npx expo install --fix${options.legacy ? ' -- --legacy-peer-deps' : ''}`)
+    }
+
+    console.log(cosmetic.bold.green('\nDone.'))
+  })