@jayrdeaton/scripts 1.1.2 → 1.1.3

package/README.md

@@ -149,6 +149,21 @@ Example: `jrd find-dep react-native expo`
 
 ---
 
+### `jrd find-script`
+
+Find projects in a directory whose `package.json` scripts contain an exact command value.
+
+```
+jrd find-script <command> [options]
+
+Options:
+  -d, --dir <dir>   Root directory to scan (default: ~/Developer)
+```
+
+Example: `jrd find-script "eslint . --fix"`
+
+---
+
 ### `jrd focus`
 
 Bring an application to the front using AppleScript.
@@ -161,6 +176,21 @@ Default app is `Terminal`.
 
 ---
 
+### `jrd including`
+
+Find projects in a directory that contain a given file.
+
+```
+jrd including <file> [options]
+
+Options:
+  -d, --dir <dir>   Root directory to scan (default: ~/Developer)
+```
+
+Example: `jrd including PLAN.md`
+
+---
+
 ### `jrd folder-sizes`
 
 List all subdirectories sorted by size, largest first.
@@ -171,6 +201,21 @@ jrd folder-sizes [dir]
 
 ---
 
+### `jrd missing`
+
+Find projects in a directory that are missing a given file.
+
+```
+jrd missing <file> [options]
+
+Options:
+  -d, --dir <dir>   Root directory to scan (default: ~/Developer)
+```
+
+Example: `jrd missing README.md`
+
+---
+
 ### `jrd new-expo-project`
 
 Bootstrap a new Expo project from the boilerplate repo. Clones or updates the boilerplate, copies it to `~/Developer/<Name>`, rewrites `package.json` and `app.json` with the derived name/slug/bundle identifiers, and creates an initial git commit.
@@ -224,6 +269,19 @@ jrd rename-season <season> [dir]
 
 ---
 
+### `jrd repo-rulesets`
+
+Find public GitHub repos that have no ruleset attached. Requires `gh auth login`.
+
+```
+jrd repo-rulesets [options]
+
+Options:
+  -u, --user <user>   GitHub username (defaults to authenticated user)
+```
+
+---
+
 ### `jrd repo-status`
 
 Scan a directory of git repos and report which ones have dirty files, untracked files, or unpushed commits.
@@ -234,6 +292,23 @@ jrd repo-status [dir]
 
 ---
 
+### `jrd sync-peers`
+
+Sync `@rific` package `peerDependency` floors and `devDependency` versions to match Expo-Starter. Dry run by default.
+
+```
+jrd sync-peers [options]
+
+Options:
+  -s, --starter <path>   Path to Expo-Starter project (default: ~/Developer/Expo-Starter)
+  -r, --root <path>      Root directory containing @rific packages (default: ~/Developer)
+  -d, --dry              Preview changes without writing
+  -i, --install          Run npm install in each changed repo
+  -t, --test             Run npm test in each changed repo (implies --install)
+```
+
+---
+
 ### `jrd update-boilerplate`
 
 Update the Expo boilerplate repo — clones it if absent, runs `jrd update-deps`, lint-fixes, type-checks, tests, then commits and pushes the result.
@@ -257,6 +332,19 @@ Options:
   -l, --legacy   Pass --legacy-peer-deps to npm install
 ```
 
+### `jrd yalc-check`
+
+Find projects in a directory that have yalc dependencies (version entries starting with `file:.yalc/` or a `yalc.lock` present).
+
+```
+jrd yalc-check [options]
+
+Options:
+  -d, --dir <dir>   Root directory to scan (default: ~/Developer)
+```
+
+---
+
 ## Requirements
 
 Node >= 20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jayrdeaton/scripts",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "private": false,
   "description": "Personal dev scripts",
   "repository": {

package/src/commands/check-scripts.mjs

@@ -85,13 +85,9 @@ export const command = Program.command('check-scripts', '[scripts...]')
       const withScript = projects.filter((p) => p.scripts[scriptName] !== undefined)
       if (withScript.length < 2 && !refProject) continue
 
-      const expectedValue = refProject
-        ? refProject.scripts[scriptName]
-        : mostCommon(withScript.map((p) => p.scripts[scriptName]))
+      const expectedValue = refProject ? refProject.scripts[scriptName] : mostCommon(withScript.map((p) => p.scripts[scriptName]))
 
-      const allMatch =
-        withScript.every((p) => p.scripts[scriptName] === expectedValue) &&
-        (!refProject || projects.every((p) => p.scripts[scriptName] !== undefined))
+      const allMatch = withScript.every((p) => p.scripts[scriptName] === expectedValue) && (!refProject || projects.every((p) => p.scripts[scriptName] !== undefined))
 
       if (!options.all && allMatch) continue
 

package/src/commands/find-script.mjs

@@ -0,0 +1,81 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+import { Color, Program, Spinner } from 'termkit'
+
+function findMatches(pkgPath, command) {
+  let pkg
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+  } catch {
+    return null
+  }
+
+  if (!pkg.scripts) return null
+
+  const found = Object.entries(pkg.scripts)
+    .filter(([, value]) => value === command)
+    .map(([key]) => key)
+
+  return found.length ? { projectName: pkg.name, found } : null
+}
+
+export const command = Program.command('find-script', '<command>')
+  .description('Find projects whose package.json scripts contain an exact command value')
+  .option('d', 'dir', '[dir]', 'Root directory to scan (default: ~/Developer)')
+  .action(async (options) => {
+    const target = options.command
+
+    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 match = findMatches(join(dir, 'package.json'), target)
+      if (match) results.push({ dir: name, ...match })
+    }
+
+    if (!results.length) {
+      spinner.succeed(`No projects found with script: ${target}`)
+      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 key of result.found) {
+        console.log(`    ${Color.cyan(key)}`)
+      }
+    }
+
+    console.log()
+  })

package/src/commands/folder-sizes.mjs

@@ -1,4 +1,5 @@
 import { readdirSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
 import { join, resolve } from 'node:path'
 
 import { Color, Program, Spinner } from 'termkit'
@@ -32,7 +33,7 @@ export const command = Program.command('folder-sizes')
   .description('List folders sorted by size, largest first')
   .variable('[dir]')
   .action(async (args) => {
-    const root = resolve(args.dir ?? '.')
+    const root = resolve(args.dir ?? join(homedir(), 'Developer'))
 
     let entries
     try {

package/src/commands/including.mjs

@@ -0,0 +1,61 @@
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+import { Color, Program, Spinner } from 'termkit'
+
+export const command = Program.command('including', '[file]')
+  .description('Find projects in a directory that contain a given file')
+  .option('d', 'dir', '[dir]', 'Root directory to scan (default: ~/Developer)')
+  .action(async (options) => {
+    const file = options.file
+
+    if (!file) {
+      console.error(Color.red('Provide a file name to search for.'))
+      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 found = []
+
+    for (const name of entries) {
+      const dir = join(root, name)
+      try {
+        if (!statSync(dir).isDirectory()) continue
+      } catch {
+        continue
+      }
+
+      spinner.message(name)
+
+      if (!existsSync(join(dir, 'package.json'))) continue
+      if (existsSync(join(dir, file))) found.push(name)
+    }
+
+    if (!found.length) {
+      spinner.succeed(`No projects found containing: ${file}`)
+      return
+    }
+
+    spinner.stop()
+
+    console.log(Color.bold(`\n${found.length} project${found.length !== 1 ? 's' : ''} containing ${Color.cyan(file)}:\n`))
+
+    for (const name of found) {
+      console.log(`  ${Color.green(name)}`)
+    }
+
+    console.log()
+  })

package/src/commands/missing.mjs

@@ -0,0 +1,61 @@
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+import { Color, Program, Spinner } from 'termkit'
+
+export const command = Program.command('missing', '[file]')
+  .description('Find projects in a directory that are missing a given file')
+  .option('d', 'dir', '[dir]', 'Root directory to scan (default: ~/Developer)')
+  .action(async (options) => {
+    const file = options.file
+
+    if (!file) {
+      console.error(Color.red('Provide a file name to search for.'))
+      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 missing = []
+
+    for (const name of entries) {
+      const dir = join(root, name)
+      try {
+        if (!statSync(dir).isDirectory()) continue
+      } catch {
+        continue
+      }
+
+      spinner.message(name)
+
+      if (!existsSync(join(dir, 'package.json'))) continue
+      if (!existsSync(join(dir, file))) missing.push(name)
+    }
+
+    if (!missing.length) {
+      spinner.succeed(`All projects contain: ${file}`)
+      return
+    }
+
+    spinner.stop()
+
+    console.log(Color.bold(`\n${missing.length} project${missing.length !== 1 ? 's' : ''} missing ${Color.cyan(file)}:\n`))
+
+    for (const name of missing) {
+      console.log(`  ${Color.yellow(name)}`)
+    }
+
+    console.log()
+  })

package/src/commands/repo-rulesets.mjs

@@ -0,0 +1,73 @@
+import { execSync } from 'node:child_process'
+
+import { Color, Program, Spinner } from 'termkit'
+
+function gh(path) {
+  const out = execSync(`gh api "${path}" --paginate`, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore']
+  })
+  return JSON.parse(out)
+}
+
+export const command = Program.command('repo-rulesets')
+  .description('Find public repos that have no ruleset attached')
+  .option('u', 'user', '<user>', 'GitHub username (defaults to authenticated user)')
+  .action(async (options) => {
+    const spinner = new Spinner({ text: 'Resolving user...' })
+    spinner.start()
+
+    let user = options.user
+    if (!user) {
+      try {
+        const data = gh('/user')
+        user = data.login
+      } catch {
+        spinner.fail('Could not resolve GitHub user. Run `gh auth login` or pass --user.')
+        process.exit(1)
+      }
+    }
+
+    spinner.message(`Fetching public repos for ${user}...`)
+
+    let repos
+    try {
+      repos = gh(`/users/${user}/repos?type=public&per_page=100`)
+    } catch {
+      spinner.fail(`Could not fetch repos for ${user}.`)
+      process.exit(1)
+    }
+
+    if (!repos.length) {
+      spinner.succeed(`No public repos found for ${user}.`)
+      return
+    }
+
+    spinner.message(`Checking rulesets across ${repos.length} repos...`)
+
+    const missing = []
+
+    for (const repo of repos) {
+      spinner.message(repo.name)
+      try {
+        const rulesets = gh(`/repos/${user}/${repo.name}/rulesets`)
+        if (!rulesets.length) missing.push(repo.name)
+      } catch {
+        // API error means no access or rulesets not available — treat as missing
+        missing.push(repo.name)
+      }
+    }
+
+    if (!missing.length) {
+      spinner.succeed(`All ${repos.length} public repos have a ruleset.`)
+      return
+    }
+
+    spinner.stop()
+
+    console.log(Color.bold.yellow(`\nNo ruleset (${missing.length} of ${repos.length})\n`))
+    for (const name of missing) {
+      console.log(`  ${Color.yellow(name)}`)
+    }
+    console.log()
+  })

package/src/commands/repo-status.mjs

@@ -1,5 +1,6 @@
 import { execSync } from 'node:child_process'
 import { readdirSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
 import { join, resolve } from 'node:path'
 
 import { Color, Program, Spinner } from 'termkit'
@@ -37,7 +38,7 @@ export const command = Program.command('repo-status')
   .description('Report dirty and untracked files across repos in a directory')
   .variable('[dir]')
   .action(async (args) => {
-    const root = resolve(args.dir ?? '.')
+    const root = resolve(args.dir ?? join(homedir(), 'Developer'))
 
     let entries
     try {

package/src/commands/sync-peers.mjs

@@ -0,0 +1,166 @@
+import { execSync } from 'node:child_process'
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+import { Color, log, Program } from 'termkit'
+
+const NON_SEMVER = /^(file:|link:|workspace:|git\+|github:|https?:|\/)/
+
+const RUNTIME_PATTERNS = [/^react$/, /^react-dom$/, /^react-native/, /^expo(-|$)/, /^@expo\//, /^@gorhom\//, /^@shopify\//, /^@reduxjs\//]
+
+function isRuntimeDep(name) {
+  return RUNTIME_PATTERNS.some((p) => p.test(name))
+}
+
+function stripRange(raw) {
+  return raw.replace(/^[\^~>=<\s]+/, '').trim()
+}
+
+function toFloor(raw) {
+  if (NON_SEMVER.test(raw.trim())) return null
+  const clean = stripRange(raw)
+  if (!/^\d/.test(clean)) return null
+  const parts = clean.split('.')
+  const major = parseInt(parts[0], 10) || 0
+  const minor = parseInt(parts[1], 10) || 0
+  return `>=${major}.${minor}.0`
+}
+
+function isSemver(raw) {
+  return !NON_SEMVER.test(raw.trim()) && /^\d/.test(stripRange(raw))
+}
+
+function sortedDeps(deps) {
+  return Object.fromEntries(Object.entries(deps).sort(([a], [b]) => a.localeCompare(b)))
+}
+
+function readPkg(dir) {
+  try {
+    return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+export const command = Program.command('sync-peers')
+  .description('Sync @rific peerDependency floors and devDependency versions to match Expo-Starter')
+  .option('s', 'starter', '[starter]', 'Path to Expo-Starter project (default: ~/Developer/Expo-Starter)')
+  .option('r', 'root', '[root]', 'Root directory containing @rific packages (default: ~/Developer)')
+  .option('d', 'dry', null, 'Preview changes without writing')
+  .option('i', 'install', null, 'Run npm install in each changed repo')
+  .option('t', 'test', null, 'Run npm test in each changed repo (implies --install)')
+  .action(async (options) => {
+    const starterPath = resolve(options.starter ?? join(homedir(), 'Developer', 'Expo-Starter'))
+    const rootPath = resolve(options.root ?? join(homedir(), 'Developer'))
+    const isDry = !!options.dry
+    const shouldTest = !!options.test
+    const shouldInstall = !!options.install || shouldTest
+
+    const starterPkg = readPkg(starterPath)
+    if (!starterPkg) {
+      log.fail(`No package.json found at: ${starterPath}`)
+      process.exit(1)
+    }
+
+    const starterDeps = { ...starterPkg.dependencies, ...starterPkg.devDependencies }
+    const expoVersion = starterDeps.expo ? stripRange(starterDeps.expo) : 'unknown'
+    log.info(`Expo SDK floor: ${expoVersion}`)
+
+    const entries = readdirSync(rootPath).filter((name) => {
+      try {
+        return statSync(join(rootPath, name)).isDirectory()
+      } catch {
+        return false
+      }
+    })
+
+    const rificPkgs = entries
+      .map((name) => {
+        const dir = join(rootPath, name)
+        const pkg = readPkg(dir)
+        if (!pkg?.name?.startsWith('@rific/')) return null
+        return { name, dir, pkg }
+      })
+      .filter(Boolean)
+      .sort((a, b) => a.name.localeCompare(b.name))
+
+    log.info(`Found ${rificPkgs.length} @rific packages\n`)
+
+    let totalChanges = 0
+
+    for (const { name, dir, pkg } of rificPkgs) {
+      const peerUpdates = {}
+      const devUpdates = {}
+
+      for (const [dep, current] of Object.entries(pkg.peerDependencies ?? {})) {
+        if (!(dep in starterDeps)) continue
+        const floor = toFloor(starterDeps[dep])
+        if (!floor || floor === current) continue
+        peerUpdates[dep] = { from: current, to: floor }
+      }
+
+      for (const [dep, current] of Object.entries(pkg.devDependencies ?? {})) {
+        if (!isRuntimeDep(dep) || !(dep in starterDeps)) continue
+        const next = starterDeps[dep]
+        if (!isSemver(next) || next === current) continue
+        devUpdates[dep] = { from: current, to: next }
+      }
+
+      const hasChanges = Object.keys(peerUpdates).length > 0 || Object.keys(devUpdates).length > 0
+
+      if (!hasChanges) {
+        console.log(`${Color.bold(name)}  ${Color.faint('no changes')}`)
+        continue
+      }
+
+      console.log(Color.bold(name))
+
+      if (Object.keys(peerUpdates).length > 0) {
+        console.log(Color.faint('  peerDependencies'))
+        for (const [dep, { from, to }] of Object.entries(peerUpdates)) {
+          console.log(`    ${dep}`)
+          console.log(`      ${Color.red(from)} → ${Color.green(to)}`)
+          totalChanges++
+        }
+      }
+
+      if (Object.keys(devUpdates).length > 0) {
+        console.log(Color.faint('  devDependencies'))
+        for (const [dep, { from, to }] of Object.entries(devUpdates)) {
+          console.log(`    ${dep}`)
+          console.log(`      ${Color.red(from)} → ${Color.green(to)}`)
+          totalChanges++
+        }
+      }
+
+      if (!isDry) {
+        const updated = { ...pkg }
+        if (Object.keys(peerUpdates).length > 0) {
+          updated.peerDependencies = sortedDeps({ ...pkg.peerDependencies, ...Object.fromEntries(Object.entries(peerUpdates).map(([d, { to }]) => [d, to])) })
+        }
+        if (Object.keys(devUpdates).length > 0) {
+          updated.devDependencies = sortedDeps({ ...pkg.devDependencies, ...Object.fromEntries(Object.entries(devUpdates).map(([d, { to }]) => [d, to])) })
+        }
+        writeFileSync(join(dir, 'package.json'), JSON.stringify(updated, null, 2) + '\n')
+        if (shouldInstall) {
+          console.log(Color.faint('  npm install'))
+          execSync('npm install', { cwd: dir, stdio: 'inherit' })
+        }
+        if (shouldTest) {
+          console.log(Color.faint('  npm test'))
+          execSync('npm test', { cwd: dir, stdio: 'inherit' })
+        }
+      }
+
+      console.log()
+    }
+
+    if (totalChanges === 0) {
+      log.succeed('All dependencies already aligned.')
+    } else if (isDry) {
+      log.info(`${totalChanges} change${totalChanges !== 1 ? 's' : ''} pending — run without --dry to apply`)
+    } else {
+      log.succeed(`Applied ${totalChanges} change${totalChanges !== 1 ? 's' : ''}.`)
+    }
+  })

package/src/commands/yalc-check.mjs

@@ -0,0 +1,95 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+import { Color, Program, Spinner } from 'termkit'
+
+const DEP_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies']
+
+function findYalcDeps(pkgPath) {
+  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 [name, version] of Object.entries(pkg[field])) {
+      if (typeof version === 'string' && version.startsWith('file:.yalc/')) {
+        found.push({ name, version, field })
+      }
+    }
+  }
+
+  return { projectName: pkg.name, found }
+}
+
+export const command = Program.command('yalc-check')
+  .description('Find projects in a directory that have yalc dependencies')
+  .option('d', 'dir', '[dir]', 'Root directory to scan (default: ~/Developer)')
+  .action(async (options) => {
+    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')
+      if (!existsSync(pkgPath)) continue
+
+      const hasLock = existsSync(join(dir, 'yalc.lock'))
+      const { projectName, found } = findYalcDeps(pkgPath)
+
+      if (found.length || hasLock) {
+        results.push({ dir: name, projectName, found, hasLock })
+      }
+    }
+
+    if (!results.length) {
+      spinner.succeed('No projects with yalc dependencies found')
+      return
+    }
+
+    spinner.stop()
+
+    console.log(Color.bold(`\n${results.length} project${results.length !== 1 ? 's' : ''} with yalc dependencies:\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)
+
+      const lockNote = result.hasLock && !result.found.length ? Color.yellow('  yalc.lock present') : ''
+      console.log(`  ${label}${lockNote}`)
+
+      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()
+  })