@rimelight/cli 0.0.13 → 0.0.14

package/bin/rimelight.js

@@ -1,28 +1,29 @@
 #!/usr/bin/env node
 
-import mri from "mri"
+import { parseArgs } from "node:util"
 import { runCreate } from "../src/index.js"
 
 async function main() {
-  const args = process.argv.slice(2)
-  const parsed = mri(args, {
-    alias: {
-      h: "help",
-      v: "version",
-      g: "git",
-      i: "install",
-      d: "domain"
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      "domain": { type: "string", short: "d" },
+      "git": { type: "boolean", short: "g" },
+      "install": { type: "boolean", short: "i" },
+      "package-manager": { type: "string" },
+      "help": { type: "boolean", short: "h" },
+      "version": { type: "boolean", short: "v" }
     },
-    boolean: ["help", "version", "git", "install"],
-    string: ["package-manager", "domain"]
+    allowPositionals: true,
+    strict: false
   })
 
-  if (parsed.version) {
+  if (values.version) {
     console.log("rimelight v0.1.0")
     process.exit(0)
   }
 
-  if (parsed.help) {
+  if (values.help) {
     console.log(`
 Rimelight CLI - Manage and scaffold premium Rimelight projects.
 
@@ -47,24 +48,24 @@ Options:
     process.exit(0)
   }
 
-  const command = parsed._[0]
+  const command = positionals[0]
 
   if (command === "compare") {
-    const targetDir = parsed._[1] || "."
+    const targetDir = positionals[1] || "."
     const { runCompare } = await import("../src/index.js")
     await runCompare({ targetDir })
   } else if (command === "update") {
-    const targetDir = parsed._[1] || "."
+    const targetDir = positionals[1] || "."
     const { runUpdate } = await import("../src/index.js")
     await runUpdate({ targetDir })
   } else if (!command || command === "create") {
-    const projectName = command === "create" ? parsed._[1] : parsed._[0]
+    const projectName = command === "create" ? positionals[1] : positionals[0]
     await runCreate({
       projectName,
-      domain: parsed.domain,
-      git: parsed.git,
-      install: parsed.install,
-      packageManager: parsed["package-manager"]
+      domain: values.domain,
+      git: values.git,
+      install: values.install,
+      packageManager: values["package-manager"]
     })
   } else {
     console.error(`Unknown command: ${command}. Use "rimelight --help" to see all options.`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimelight/cli",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "private": false,
   "description": "Rimelight Entertainment's Command Line Interface",
   "homepage": "https://rimelight.com/docs",
@@ -27,23 +27,17 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@clack/prompts": "1.8.1",
-    "cross-spawn": "7.0.6",
-    "mri": "1.2.0",
-    "picocolors": "1.1.1"
+  "scripts": {
+    "create": "node ./bin/rimelight.js create",
+    "check": "vp check --fix"
   },
   "devDependencies": {
-    "@rimelight/config": "0.0.20",
-    "@types/node": "26.6.1",
+    "@rimelight/config": "workspace:*",
     "typescript": "6.0.3",
     "vite-plus": "0.3.3"
   },
   "engines": {
     "node": ">=26.9.0"
   },
-  "scripts": {
-    "create": "node ./bin/rimelight.js create",
-    "check": "vp check --fix"
-  }
-}
+  "packageManager": "pnpm@12.4.2"
+}

package/src/index.js

@@ -1,11 +1,24 @@
 import path from "node:path"
 import fs from "node:fs/promises"
 import { existsSync, readdirSync } from "node:fs"
-import * as prompts from "@clack/prompts"
-import pc from "picocolors"
-import spawn from "cross-spawn"
+import { spawnSync } from "node:child_process"
+import * as prompts from "./prompts.js"
+import { pc } from "./prompts.js"
+
+function runCommand(cmd, args, options = {}) {
+  return spawnSync(cmd, args, {
+    ...options,
+    shell: process.platform === "win32"
+  })
+}
 
-const starterPath = path.resolve(import.meta.dirname, "../../starter")
+const candidateStarterPaths = [
+  path.resolve(import.meta.dirname, "../../../apps/starter.rimelight.com"),
+  path.resolve(import.meta.dirname, "../../starter"),
+  path.resolve(import.meta.dirname, "../starter")
+]
+export const starterPath =
+  candidateStarterPaths.find((p) => existsSync(p)) || candidateStarterPaths[0]
 
 // Helper to parse JSON with comments (JSONC)
 export function parseJsonc(content) {
@@ -242,7 +255,7 @@ export async function runCreate(options) {
     if (initGit) {
       const gitSpinner = prompts.spinner()
       gitSpinner.start("Initializing Git repository...")
-      const gitInit = spawn.sync("git", ["init"], { cwd: resolvedTargetDir })
+      const gitInit = runCommand("git", ["init"], { cwd: resolvedTargetDir })
       if (gitInit.status === 0) {
         gitSpinner.stop(pc.green("✔ Git repository initialized!"))
       } else {
@@ -255,7 +268,7 @@ export async function runCreate(options) {
       const installSpinner = prompts.spinner()
       installSpinner.start(`Installing dependencies with ${packageManager}...`)
 
-      const install = spawn.sync(packageManager, ["install"], {
+      const install = runCommand(packageManager, ["install"], {
         cwd: resolvedTargetDir,
         stdio: "ignore"
       })
@@ -323,7 +336,7 @@ export async function runCreate(options) {
 
     if (initGit) {
       console.log("Initializing Git repository...")
-      const gitInit = spawn.sync("git", ["init"], { cwd: resolvedTargetDir })
+      const gitInit = runCommand("git", ["init"], { cwd: resolvedTargetDir })
       if (gitInit.status === 0) {
         console.log(pc.green("✔ Git repository initialized!"))
       } else {
@@ -333,15 +346,10 @@ export async function runCreate(options) {
 
     if (installDeps) {
       console.log(`Installing dependencies using ${packageManager}...`)
-      const install = spawn.crossSpawn
-        ? spawn.crossSpawn(packageManager, ["install"], {
-            cwd: resolvedTargetDir,
-            stdio: "ignore"
-          })
-        : spawn.sync(packageManager, ["install"], {
-            cwd: resolvedTargetDir,
-            stdio: "ignore"
-          })
+      const install = runCommand(packageManager, ["install"], {
+        cwd: resolvedTargetDir,
+        stdio: "ignore"
+      })
       if (install.status === 0) {
         console.log(pc.green("✔ Dependencies successfully installed!"))
       } else {
@@ -1288,7 +1296,7 @@ export async function runUpdate(options) {
     if (runInstall) {
       const runVpInstall = prompts.spinner()
       runVpInstall.start("Running vp install...")
-      const vpInstall = spawn.sync("vp", ["install"], { cwd: targetDir, stdio: "ignore" })
+      const vpInstall = runCommand("vp", ["install"], { cwd: targetDir, stdio: "ignore" })
       if (vpInstall.status === 0) {
         runVpInstall.stop(pc.green("✔ vp install completed successfully!"))
       } else {

package/src/prompts.js

@@ -0,0 +1,380 @@
+import readline from "node:readline"
+import readlinePromises from "node:readline/promises"
+import { styleText } from "node:util"
+
+// --- Terminal Styling (Node 22+ styleText with graceful fallback) ---
+
+export const pc = {
+  magenta: (text) => styleTextSafe("magenta", text),
+  bold: (text) => styleTextSafe("bold", text),
+  green: (text) => styleTextSafe("green", text),
+  cyan: (text) => styleTextSafe("cyan", text),
+  yellow: (text) => styleTextSafe("yellow", text),
+  red: (text) => styleTextSafe("red", text),
+  dim: (text) => styleTextSafe("dim", text)
+}
+
+function styleTextSafe(format, text) {
+  if (typeof styleText === "function") {
+    try {
+      return styleText(format, String(text))
+    } catch {
+      // fallback to raw ANSI if format is unsupported
+    }
+  }
+  const codes = {
+    bold: ["\x1b[1m", "\x1b[22m"],
+    dim: ["\x1b[2m", "\x1b[22m"],
+    red: ["\x1b[31m", "\x1b[39m"],
+    green: ["\x1b[32m", "\x1b[39m"],
+    yellow: ["\x1b[33m", "\x1b[39m"],
+    magenta: ["\x1b[35m", "\x1b[39m"],
+    cyan: ["\x1b[36m", "\x1b[39m"]
+  }
+  const [open, close] = codes[format] || ["", ""]
+  return `${open}${text}${close}`
+}
+
+// --- Cancellation Symbol & Global Terminal Cleanup ---
+
+const CANCEL_SYMBOL = Symbol("rimelight:cancel")
+
+if (typeof process !== "undefined" && typeof process.on === "function") {
+  process.on("exit", () => {
+    if (process.stdout?.isTTY) {
+      process.stdout.write("\x1b[?25h")
+    }
+  })
+}
+
+export function isCancel(value) {
+  return value === CANCEL_SYMBOL
+}
+
+export function intro(title) {
+  console.log(`\n${title}\n`)
+}
+
+export function outro(message) {
+  console.log(`\n${message}\n`)
+}
+
+export function cancel(message) {
+  console.log(`\n${pc.red(message)}\n`)
+}
+
+// --- Interactive Prompts ---
+
+export async function text(options) {
+  const { message, placeholder, validate, defaultValue = "" } = options
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY
+
+  if (!isTTY) {
+    return defaultValue
+  }
+
+  const promptMsg = placeholder ? `${message} ${pc.dim(`(${placeholder})`)}: ` : `${message}: `
+
+  while (true) {
+    const rl = readlinePromises.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    })
+
+    try {
+      const answer = await rl.question(promptMsg)
+      rl.close()
+
+      const val = answer.trim() || defaultValue
+      if (validate) {
+        const error = validate(val)
+        if (error) {
+          console.log(pc.yellow(`⚠ ${error}`))
+          continue
+        }
+      }
+      return val
+    } catch {
+      rl.close()
+      return CANCEL_SYMBOL
+    }
+  }
+}
+
+export async function confirm(options) {
+  const { message, initialValue = true } = options
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY
+
+  if (!isTTY) {
+    return initialValue
+  }
+
+  const hint = initialValue ? "[Y/n]" : "[y/N]"
+  const promptMsg = `${message} ${pc.dim(hint)}: `
+
+  const rl = readlinePromises.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  try {
+    const answer = await rl.question(promptMsg)
+    rl.close()
+
+    const trimmed = answer.trim().toLowerCase()
+    if (!trimmed) return initialValue
+    return trimmed === "y" || trimmed === "yes"
+  } catch {
+    rl.close()
+    return CANCEL_SYMBOL
+  }
+}
+
+export async function select(options) {
+  const { message, options: choices, initialValue } = options
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY
+
+  if (!isTTY || choices.length === 0) {
+    return initialValue ?? choices[0]?.value
+  }
+
+  let selectedIndex = Math.max(
+    0,
+    choices.findIndex((c) => c.value === initialValue)
+  )
+
+  return new Promise((resolve) => {
+    const { stdin, stdout } = process
+    let cleaned = false
+
+    const render = (first = false) => {
+      if (!first) {
+        // Move cursor up by (choices.length + 1) lines
+        stdout.write(`\x1b[${choices.length + 1}A\r\x1b[J`)
+      }
+      stdout.write(`${pc.magenta("?")} ${pc.bold(message)}\n`)
+      choices.forEach((choice, idx) => {
+        const isSelected = idx === selectedIndex
+        const pointer = isSelected ? pc.cyan("❯") : " "
+        const label = isSelected ? pc.cyan(choice.label) : choice.label
+        const hint = choice.hint ? ` ${pc.dim(`(${choice.hint})`)}` : ""
+        stdout.write(`  ${pointer} ${label}${hint}\n`)
+      })
+    }
+
+    const cleanup = () => {
+      if (cleaned) return
+      cleaned = true
+      stdin.removeListener("keypress", onKeyPress)
+      stdin.removeListener("error", onStdinError)
+      process.removeListener("exit", onProcessExit)
+      if (stdin.isTTY) stdin.setRawMode(false)
+      stdout.write("\x1b[?25h") // show cursor
+    }
+
+    const onStdinError = () => {
+      cleanup()
+      resolve(CANCEL_SYMBOL)
+    }
+
+    const onProcessExit = () => {
+      cleanup()
+    }
+
+    const onKeyPress = (_, key) => {
+      if (key) {
+        if (key.name === "c" && key.ctrl) {
+          cleanup()
+          resolve(CANCEL_SYMBOL)
+          return
+        }
+        if (key.name === "up" || key.name === "k") {
+          selectedIndex = (selectedIndex - 1 + choices.length) % choices.length
+          render()
+          return
+        }
+        if (key.name === "down" || key.name === "j") {
+          selectedIndex = (selectedIndex + 1) % choices.length
+          render()
+          return
+        }
+        if (key.name === "return" || key.name === "enter") {
+          cleanup()
+          resolve(choices[selectedIndex]?.value)
+          return
+        }
+        if (key.name === "escape") {
+          cleanup()
+          resolve(CANCEL_SYMBOL)
+          return
+        }
+      }
+    }
+
+    stdin.once("error", onStdinError)
+    process.once("exit", onProcessExit)
+    readline.emitKeypressEvents(stdin)
+    if (stdin.isTTY) stdin.setRawMode(true)
+    stdout.write("\x1b[?25l") // hide cursor
+    render(true)
+    stdin.on("keypress", onKeyPress)
+  })
+}
+
+export async function multiselect(options) {
+  const { message, options: choices, initialValues = [], required = false } = options
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY
+
+  if (!isTTY || choices.length === 0) {
+    return initialValues.length > 0 ? initialValues : choices.map((c) => c.value)
+  }
+
+  let selectedIndex = 0
+  const selectedSet = new Set(initialValues)
+
+  return new Promise((resolve) => {
+    const { stdin, stdout } = process
+    let cleaned = false
+
+    const render = (first = false) => {
+      if (!first) {
+        // Move cursor up by (choices.length + 2) lines
+        stdout.write(`\x1b[${choices.length + 2}A\r\x1b[J`)
+      }
+      stdout.write(
+        `${pc.magenta("?")} ${pc.bold(message)} ${pc.dim("(Space to toggle, Enter to submit)")}\n`
+      )
+      choices.forEach((choice, idx) => {
+        const isCurrent = idx === selectedIndex
+        const isChecked = selectedSet.has(choice.value)
+        const pointer = isCurrent ? pc.cyan("❯") : " "
+        const checkbox = isChecked ? pc.green("[✔]") : pc.dim("[ ]")
+        const label = isCurrent ? pc.cyan(choice.label) : choice.label
+        const hint = choice.hint ? ` ${pc.dim(`(${choice.hint})`)}` : ""
+        stdout.write(`  ${pointer} ${checkbox} ${label}${hint}\n`)
+      })
+      stdout.write(`  ${pc.dim(`${selectedSet.size} selected`)}\n`)
+    }
+
+    const cleanup = () => {
+      if (cleaned) return
+      cleaned = true
+      stdin.removeListener("keypress", onKeyPress)
+      stdin.removeListener("error", onStdinError)
+      process.removeListener("exit", onProcessExit)
+      if (stdin.isTTY) stdin.setRawMode(false)
+      stdout.write("\x1b[?25h") // show cursor
+    }
+
+    const onStdinError = () => {
+      cleanup()
+      resolve(CANCEL_SYMBOL)
+    }
+
+    const onProcessExit = () => {
+      cleanup()
+    }
+
+    const onKeyPress = (_, key) => {
+      if (key) {
+        if (key.name === "c" && key.ctrl) {
+          cleanup()
+          resolve(CANCEL_SYMBOL)
+          return
+        }
+        if (key.name === "up" || key.name === "k") {
+          selectedIndex = (selectedIndex - 1 + choices.length) % choices.length
+          render()
+          return
+        }
+        if (key.name === "down" || key.name === "j") {
+          selectedIndex = (selectedIndex + 1) % choices.length
+          render()
+          return
+        }
+        if (key.name === "space") {
+          const val = choices[selectedIndex]?.value
+          if (selectedSet.has(val)) {
+            selectedSet.delete(val)
+          } else {
+            selectedSet.add(val)
+          }
+          render()
+          return
+        }
+        if (key.name === "return" || key.name === "enter") {
+          if (required && selectedSet.size === 0) {
+            render()
+            return
+          }
+          cleanup()
+          resolve(Array.from(selectedSet))
+          return
+        }
+        if (key.name === "escape") {
+          cleanup()
+          resolve(CANCEL_SYMBOL)
+          return
+        }
+      }
+    }
+
+    stdin.once("error", onStdinError)
+    process.once("exit", onProcessExit)
+    readline.emitKeypressEvents(stdin)
+    if (stdin.isTTY) stdin.setRawMode(true)
+    stdout.write("\x1b[?25l") // hide cursor
+    render(true)
+    stdin.on("keypress", onKeyPress)
+  })
+}
+
+// --- Terminal Spinner ---
+
+export function spinner() {
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+  let frameIndex = 0
+  let intervalId = null
+  let currentMessage = ""
+  const isTTY = process.stdout.isTTY
+
+  const onProcessExit = () => {
+    if (isTTY) {
+      process.stdout.write("\x1b[?25h") // restore cursor
+    }
+  }
+
+  return {
+    start(msg = "") {
+      currentMessage = msg
+      if (isTTY) {
+        process.once("exit", onProcessExit)
+        process.stdout.write("\x1b[?25l") // hide cursor
+        intervalId = setInterval(() => {
+          const frame = pc.cyan(frames[frameIndex] || "⠋")
+          frameIndex = (frameIndex + 1) % frames.length
+          process.stdout.write(`\r${frame} ${currentMessage}`)
+        }, 80)
+      } else {
+        console.log(`ℹ ${msg}`)
+      }
+    },
+    message(msg = "") {
+      currentMessage = msg
+    },
+    stop(finalMessage = "") {
+      if (intervalId) {
+        clearInterval(intervalId)
+        intervalId = null
+      }
+      if (isTTY) {
+        process.removeListener("exit", onProcessExit)
+        process.stdout.write(`\r\x1b[K`) // clear line
+        process.stdout.write("\x1b[?25h") // show cursor
+      }
+      if (finalMessage) {
+        console.log(finalMessage)
+      }
+    }
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Rimelight Entertainment
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.