@jayrdeaton/scripts 1.1.1 → 1.1.3

package/README.md

@@ -69,6 +69,22 @@ Example: `jrd check-domains ??fu.com`
 
 ---
 
+### `jrd check-scripts`
+
+Compare `package.json` scripts across projects for consistency. Highlights scripts whose values differ from the most common value (or a reference project).
+
+```
+jrd check-scripts [scripts...] [options]
+
+Options:
+  -d, --dir <dir>   Root directory to scan (default: ~/Developer)
+  -r, --ref <ref>   Reference project name to compare against
+  -a, --all         Show all scripts, including matching ones
+  -f, --flat        Show one line per project instead of grouping by value
+```
+
+---
+
 ### `jrd clean-builds`
 
 Delete build artifacts (`build`, `dist`, `ios`, `android`) across one or more repos. Dry run by default.
@@ -118,6 +134,36 @@ Options:
 
 ---
 
+### `jrd find-dep`
+
+Find projects in a directory that use any of the given dependencies (searches `dependencies`, `devDependencies`, and `peerDependencies`).
+
+```
+jrd find-dep <deps...> [options]
+
+Options:
+  -d, --dir <dir>   Root directory to scan (default: ~/Developer)
+```
+
+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.
@@ -130,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.
@@ -140,6 +201,36 @@ 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.
+
+```
+jrd new-expo-project [options]
+
+Options:
+  -n, --name <name>   Project name (required)
+```
+
+Example: `jrd new-expo-project --name MyApp`
+
+---
+
 ### `jrd npm-downloads`
 
 List all your npm packages sorted by total downloads.
@@ -178,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.
@@ -188,6 +292,33 @@ 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.
+
+```
+jrd update-boilerplate
+```
+
+---
+
 ### `jrd update-deps`
 
 Update all npm dependencies to `@latest`. Automatically runs `npx expo install --fix` if the project uses Expo.
@@ -201,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.1",
+  "version": "1.1.3",
   "private": false,
   "description": "Personal dev scripts",
   "repository": {

package/src/commands/base64.mjs

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync } from 'node:fs'
 import { execSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
 
 import { Color, Program } from 'termkit'
 
@@ -41,5 +41,5 @@ export const command = Program.command('base64')
       .action(({ value, copy }) => {
         const result = Buffer.from(value, 'base64').toString('utf8')
         output(result, copy)
-      }),
+      })
   ])

package/src/commands/binary.mjs

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { execSync } from 'node:child_process'
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 
 import { Color, Program } from 'termkit'
 
@@ -34,5 +34,5 @@ export const command = Program.command('binary')
         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/check-scripts.mjs

@@ -0,0 +1,145 @@
+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 loadProject(pkgPath) {
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+    return { name: pkg.name, scripts: pkg.scripts ?? {} }
+  } catch {
+    return null
+  }
+}
+
+function mostCommon(values) {
+  const freq = {}
+  for (const v of values) freq[v] = (freq[v] ?? 0) + 1
+  return Object.entries(freq).sort((a, b) => b[1] - a[1])[0][0]
+}
+
+export const command = Program.command('check-scripts', '[scripts...]')
+  .description('Compare package.json scripts across projects for consistency')
+  .option('d', 'dir', '[dir]', 'Root directory to scan (default: ~/Developer)')
+  .option('r', 'ref', '[ref]', 'Reference project name to compare against')
+  .option('a', 'all', null, 'Show all scripts, including matching ones')
+  .option('f', 'flat', null, 'Show one line per project instead of grouping by value')
+  .action(async (options) => {
+    const root = resolve(options.dir ?? join(homedir(), 'Developer'))
+    const filterScripts = options.scripts ?? []
+
+    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 projects = []
+
+    for (const entry of entries) {
+      const dir = join(root, entry)
+      try {
+        if (!statSync(dir).isDirectory()) continue
+      } catch {
+        continue
+      }
+      spinner.message(entry)
+      const result = loadProject(join(dir, 'package.json'))
+      if (result) projects.push({ dir: entry, ...result })
+    }
+
+    spinner.stop()
+
+    if (!projects.length) {
+      console.log(Color.yellow('No projects with package.json found.'))
+      return
+    }
+
+    let refProject = null
+    if (options.ref) {
+      refProject = projects.find((p) => p.dir === options.ref || p.name === options.ref)
+      if (!refProject) {
+        console.error(Color.red(`Reference project not found: ${options.ref}`))
+        process.exit(1)
+      }
+    }
+
+    const allScriptNames = new Set()
+    for (const p of projects) {
+      for (const key of Object.keys(p.scripts)) {
+        if (!filterScripts.length || filterScripts.includes(key)) {
+          allScriptNames.add(key)
+        }
+      }
+    }
+
+    let printed = 0
+
+    for (const scriptName of [...allScriptNames].sort()) {
+      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 allMatch = withScript.every((p) => p.scripts[scriptName] === expectedValue) && (!refProject || projects.every((p) => p.scripts[scriptName] !== undefined))
+
+      if (!options.all && allMatch) continue
+
+      console.log(`\n${Color.bold(scriptName)}`)
+
+      if (options.flat) {
+        // Per-project lines
+        const allRelevant = refProject ? projects : withScript
+        for (const p of allRelevant) {
+          const value = p.scripts[scriptName]
+          const missing = value === undefined
+          const matches = !missing && value === expectedValue
+          const icon = matches ? Color.green('✓') : Color.red('✗')
+          const label = matches ? Color.faint(p.dir) : Color.bold(p.dir)
+          const display = missing ? Color.faint('(missing)') : Color.faint(value)
+          console.log(`  ${icon} ${label}  ${display}`)
+        }
+      } else {
+        // Grouped by value
+        const groups = new Map()
+        const allRelevant = refProject ? projects : withScript
+
+        for (const p of allRelevant) {
+          const value = p.scripts[scriptName] ?? null
+          if (!groups.has(value)) groups.set(value, [])
+          groups.get(value).push(p.dir)
+        }
+
+        // Sort: expected value first, then others, missing last
+        const sorted = [...groups.entries()].sort(([a], [b]) => {
+          if (a === expectedValue) return -1
+          if (b === expectedValue) return 1
+          if (a === null) return 1
+          if (b === null) return -1
+          return 0
+        })
+
+        for (const [value, dirs] of sorted) {
+          const matches = value === expectedValue
+          const icon = matches ? Color.green('✓') : Color.red('✗')
+          const label = matches ? Color.faint(dirs.join(', ')) : Color.bold(dirs.join(', '))
+          const display = value === null ? Color.faint('(missing)') : Color.faint(value)
+          console.log(`  ${icon} ${label}  ${display}`)
+        }
+      }
+
+      printed++
+    }
+
+    if (!printed) {
+      console.log(Color.green('\nAll scripts are consistent across projects.'))
+    } else {
+      console.log()
+    }
+  })

package/src/commands/clean-junk.mjs

@@ -1,7 +1,7 @@
-import { extname, basename } from 'node:path'
 import { readdirSync, rmSync, statSync } from 'node:fs'
-import { createInterface } from 'node:readline'
+import { basename, extname } from 'node:path'
 import { join, resolve } from 'node:path'
+import { createInterface } from 'node:readline'
 
 import { Color, Program, Spinner } from 'termkit'
 

package/src/commands/find-dep.mjs

@@ -1,4 +1,4 @@
-import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { readdirSync, readFileSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, resolve } from 'node:path'
 
@@ -77,16 +77,12 @@ export const command = Program.command('find-dep', '[deps...]')
     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)
+      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'
+        const fieldLabel = dep.field === 'dependencies' ? 'dep' : dep.field === 'devDependencies' ? 'dev' : 'peer'
         console.log(`    ${Color.cyan(dep.name)}  ${Color.faint(`${dep.version}  [${fieldLabel}]`)}`)
       }
     }

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/new-expo-project.mjs

@@ -3,7 +3,7 @@ import { cpSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
-import { Color, Program, log } from 'termkit'
+import { Color, log, Program } from 'termkit'
 
 const BOILERPLATE_REPO = 'git@github.com:jayrdeaton/Expo-Boilerplate.git'
 const BOILERPLATE_DIR = join(homedir(), 'Developer', 'Expo-Boilerplate')
@@ -49,7 +49,7 @@ export const command = Program.command('new-expo-project')
     log.info(`Creating ${displayName}...`)
     cpSync(BOILERPLATE_DIR, targetDir, {
       recursive: true,
-      filter: (src) => !src.includes('/node_modules/'),
+      filter: (src) => !src.includes('/node_modules/')
     })
 
     rmSync(join(targetDir, '.git'), { recursive: true, force: true })

package/src/commands/rename-season.mjs

@@ -1,7 +1,7 @@
 import { readdirSync, renameSync, statSync } from 'node:fs'
 import { extname, join } from 'node:path'
 
-import { Color, Program, log } from 'termkit'
+import { Color, log, Program } from 'termkit'
 
 export const command = Program.command('rename-season')
   .description('Rename files in a directory to SxEE format for TV library pickup')

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/update-boilerplate.mjs

@@ -3,7 +3,7 @@ import { existsSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
-import { Color, Program, log } from 'termkit'
+import { Color, log, Program } from 'termkit'
 
 const BOILERPLATE_REPO = 'git@github.com:jayrdeaton/Expo-Boilerplate.git'
 const BOILERPLATE_DIR = join(homedir(), 'Developer', 'Expo-Boilerplate')

package/src/commands/update-deps.mjs

@@ -2,7 +2,7 @@ import { execSync } from 'node:child_process'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-import { Color, Program, log } from 'termkit'
+import { Color, log, Program } from 'termkit'
 
 function exec(cmd) {
   console.log(Color.faint(`$ ${cmd}`))

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()
+  })