@remix-run/cli 0.1.0 → 0.3.0

package/dist/lib/route-map.js

@@ -3,12 +3,12 @@ import * as path from 'node:path';
 import * as process from 'node:process';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { inspectControllerOwnership } from "./controller-ownership.js";
+import { ROOT_ROUTE_NAME, inspectControllerOwnership, } from "./controller-ownership.js";
 import { routeMapLoaderFailed, routeMapLoaderInvalidJson, routeMapLoaderSignal, routeOwnerPlanUnresolved, routesFileNotFound, } from "./errors.js";
 export async function loadRouteMap(cwd = process.cwd()) {
     let manifest = await loadRouteManifest(cwd);
     let ownership = await inspectControllerOwnership(manifest.appRoot, manifest.tree);
-    let tree = decorateRouteTree(manifest.tree, ownership.subtrees);
+    let tree = decorateRouteTree(manifest.tree, ownership);
     return {
         appRoot: manifest.appRoot,
         routesFile: manifest.routesFile,
@@ -70,17 +70,18 @@ async function loadRawRouteMap(appRoot, routesFile) {
     }
     return assertRawRouteTree(parsed);
 }
-function decorateRouteTree(rawTree, subtrees, parentSegments = []) {
-    let subtreesByRouteName = new Map(subtrees.map((subtree) => [subtree.routeName, subtree]));
-    return decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, parentSegments);
+function decorateRouteTree(rawTree, ownership) {
+    let subtreesByRouteName = new Map(ownership.subtrees.map((subtree) => [subtree.routeName, subtree]));
+    let directoriesByRouteName = new Map(ownership.routeDirectories.map((directory) => [directory.routeName, directory]));
+    return decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, directoriesByRouteName, ownership.scan.routeDirectoryPaths);
 }
-function decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, parentSegments = []) {
+function decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, directoriesByRouteName, actualRouteDirectories, parentSegments = []) {
     return rawTree.map((rawNode) => {
-        let owner = getRouteOwner(rawNode, parentSegments, subtreesByRouteName);
+        let owner = getRouteOwner(rawNode, parentSegments, subtreesByRouteName, directoriesByRouteName, actualRouteDirectories);
         let nextParentSegments = rawNode.kind === 'group' ? [...parentSegments, rawNode.key] : parentSegments;
         return {
             children: rawNode.kind === 'group'
-                ? decorateRouteTreeWithLookup(rawNode.children, subtreesByRouteName, nextParentSegments)
+                ? decorateRouteTreeWithLookup(rawNode.children, subtreesByRouteName, directoriesByRouteName, actualRouteDirectories, nextParentSegments)
                 : [],
             key: rawNode.key,
             kind: rawNode.kind,
@@ -91,21 +92,32 @@ function decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, parentSegment
         };
     });
 }
-function getRouteOwner(rawNode, parentSegments, subtreesByRouteName) {
+function getRouteOwner(rawNode, parentSegments, subtreesByRouteName, directoriesByRouteName, actualRouteDirectories) {
     let ownerRouteName = rawNode.kind === 'group'
         ? rawNode.name
         : parentSegments.length === 0
-            ? rawNode.name
+            ? ROOT_ROUTE_NAME
             : parentSegments.join('.');
     let subtree = subtreesByRouteName.get(ownerRouteName);
-    if (subtree == null) {
-        throw routeOwnerPlanUnresolved(rawNode.name);
+    if (subtree != null) {
+        return {
+            exists: subtree.actualEntryPath != null,
+            kind: 'controller',
+            path: subtree.actualEntryPath ?? subtree.entryDisplayPath,
+        };
     }
-    return {
-        exists: subtree.actualEntryPath != null,
-        kind: subtree.kind,
-        path: subtree.actualEntryPath ?? subtree.entryDisplayPath,
-    };
+    if (rawNode.kind === 'group') {
+        let directory = directoriesByRouteName.get(rawNode.name);
+        if (directory == null) {
+            throw routeOwnerPlanUnresolved(rawNode.name);
+        }
+        return {
+            exists: actualRouteDirectories.has(directory.directoryPath),
+            kind: 'directory',
+            path: directory.directoryPath,
+        };
+    }
+    throw routeOwnerPlanUnresolved(rawNode.name);
 }
 function assertRawRouteTree(value) {
     if (!Array.isArray(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remix-run/cli",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Command-line interface for Remix",
   "author": "Michael Jackson <mjijackson@gmail.com>",
   "license": "MIT",
@@ -11,11 +11,11 @@
   },
   "homepage": "https://github.com/remix-run/remix/tree/main/packages/cli#readme",
   "files": [
-    "bootstrap",
     "LICENSE",
     "README.md",
     "dist",
     "src",
+    "template",
     "!src/**/*.test.ts"
   ],
   "type": "module",
@@ -31,15 +31,14 @@
   },
   "dependencies": {
     "semver": "^7.7.4",
-    "@remix-run/test": "^0.2.0",
-    "@remix-run/tar-parser": "^0.7.1",
+    "@remix-run/test": "^0.4.0",
     "@remix-run/terminal": "^0.1.0"
   },
   "devDependencies": {
     "@types/node": "^24.6.0",
     "@types/semver": "^7.5.8",
     "@typescript/native-preview": "7.0.0-dev.20251125.1",
-    "@remix-run/assert": "^0.1.0"
+    "@remix-run/assert": "^0.2.0"
   },
   "keywords": [
     "remix",

package/src/lib/bootstrap-project.ts

@@ -12,11 +12,10 @@ import {
 } from './errors.ts'
 import { runProgressStep, type StepProgressReporter } from './reporter.ts'
 
-const BOOTSTRAP_DIRECTORY = path.resolve(
-  path.dirname(fileURLToPath(import.meta.url)),
-  '../../bootstrap',
-)
-const BOOTSTRAP_EXCLUDED_NAMES = new Set(['.gitkeep', 'node_modules'])
+const MODULE_DIRECTORY = path.dirname(fileURLToPath(import.meta.url))
+const PACKAGE_TEMPLATE_DIRECTORY = path.resolve(MODULE_DIRECTORY, '../../template')
+const REPO_TEMPLATE_DIRECTORY = path.resolve(MODULE_DIRECTORY, '../../../../template')
+const TEMPLATE_EXCLUDED_NAMES = new Set(['.gitkeep', 'node_modules'])
 export const MINIMUM_SUPPORTED_NODE_VERSION = '24.3.0'
 
 export interface BootstrapProjectOptions {
@@ -67,9 +66,9 @@ export async function bootstrapProject(
   await runProgressStep(progress, 'prepare-target-directory', () =>
     ensureTargetDirectory(targetDir, options.force),
   )
-  await runProgressStep(progress, 'generate-scaffold-files', () =>
-    copyBootstrapDirectory({
-      sourceDir: BOOTSTRAP_DIRECTORY,
+  await runProgressStep(progress, 'generate-scaffold-files', async () =>
+    copyTemplateDirectory({
+      sourceDir: await resolveTemplateDirectory(),
       targetDir,
       templateValues: createTemplateValues(config),
     }),
@@ -105,6 +104,34 @@ function createTemplateValues(config: BootstrapConfig): TemplateValues {
   }
 }
 
+async function resolveTemplateDirectory(): Promise<string> {
+  if (await isDirectory(PACKAGE_TEMPLATE_DIRECTORY)) {
+    return PACKAGE_TEMPLATE_DIRECTORY
+  }
+
+  if (await isDirectory(REPO_TEMPLATE_DIRECTORY)) {
+    return REPO_TEMPLATE_DIRECTORY
+  }
+
+  throw new Error(
+    `Could not find the Remix app template at ${PACKAGE_TEMPLATE_DIRECTORY} or ${REPO_TEMPLATE_DIRECTORY}.`,
+  )
+}
+
+async function isDirectory(directory: string): Promise<boolean> {
+  try {
+    let stats = await fs.stat(directory)
+    return stats.isDirectory()
+  } catch (error) {
+    let nodeError = error as NodeJS.ErrnoException
+    if (nodeError.code === 'ENOENT') {
+      return false
+    }
+
+    throw error
+  }
+}
+
 async function writeScaffoldPackageJson(targetDir: string, config: BootstrapConfig): Promise<void> {
   let packageJsonPath = path.join(targetDir, 'package.json')
   let packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8')) as {
@@ -118,7 +145,6 @@ async function writeScaffoldPackageJson(targetDir: string, config: BootstrapConf
   packageJson.dependencies = {
     ...packageJson.dependencies,
     remix: config.remixVersion,
-    tsx: 'latest',
   }
   packageJson.devDependencies = {
     ...packageJson.devDependencies,
@@ -154,7 +180,7 @@ async function ensureTargetDirectory(targetDir: string, force: boolean): Promise
   await fs.mkdir(targetDir, { recursive: true })
 }
 
-async function copyBootstrapDirectory({
+async function copyTemplateDirectory({
   sourceDir,
   targetDir,
   templateValues,
@@ -167,15 +193,15 @@ async function copyBootstrapDirectory({
 
   for (let entry of entries) {
     let sourcePath = path.join(sourceDir, entry.name)
-    let targetPath = path.join(targetDir, entry.name)
+    let targetPath = path.join(targetDir, entry.name === 'gitignore' ? '.gitignore' : entry.name)
 
-    if (BOOTSTRAP_EXCLUDED_NAMES.has(entry.name)) {
+    if (TEMPLATE_EXCLUDED_NAMES.has(entry.name)) {
       continue
     }
 
     if (entry.isDirectory()) {
       await fs.mkdir(targetPath, { recursive: true })
-      await copyBootstrapDirectory({ sourceDir: sourcePath, targetDir: targetPath, templateValues })
+      await copyTemplateDirectory({ sourceDir: sourcePath, targetDir: targetPath, templateValues })
       continue
     }
 

package/src/lib/cli.ts

@@ -1,22 +1,44 @@
 import * as process from 'node:process'
 
-import { runCompletionCommand } from './commands/completion.ts'
-import { runDoctorCommand } from './commands/doctor.ts'
 import { getCliHelpText, runHelpCommand } from './commands/help.ts'
-import { runNewCommand } from './commands/new.ts'
-import { runRoutesCommand } from './commands/routes.ts'
-import { runSkillsCommand } from './commands/skills.ts'
-import { runTestCommand } from './commands/test.ts'
-import { runVersionCommand } from './commands/version.ts'
 import { resolveCliContext, type CliContext } from './cli-context.ts'
 import { renderCliError, unknownCommand } from './errors.ts'
 import { configureColors, restoreTerminalFormatting } from './terminal.ts'
 
+/**
+ * Options accepted by {@link runRemix}.
+ */
 export interface RunRemixOptions {
+  /**
+   * Directory used as the working root when resolving project files (default
+   * `process.cwd()`).
+   */
   cwd?: string
+  /**
+   * Override for the Remix version reported by `remix --version`. Defaults to
+   * the version of the installed `@remix-run/cli` package.
+   */
   remixVersion?: string
 }
 
+/**
+ * Entry point for the `remix` CLI. Parses `argv`, dispatches to the matching
+ * subcommand (`new`, `doctor`, `routes`, `test`, `version`, `completion`,
+ * `help`), and resolves with the exit code the process should use.
+ *
+ * @param argv Argument vector to parse, excluding the node and script paths
+ *             (default `process.argv.slice(2)`).
+ * @param options Overrides for CLI context resolution.
+ * @returns The numeric exit code (`0` on success, non-zero on failure).
+ *
+ * @example
+ * ```ts
+ * import { runRemix } from '@remix-run/cli'
+ *
+ * let exitCode = await runRemix(process.argv.slice(2))
+ * process.exit(exitCode)
+ * ```
+ */
 export async function runRemix(
   argv: string[] = process.argv.slice(2),
   options: RunRemixOptions = {},
@@ -24,12 +46,10 @@ export async function runRemix(
   let context = await resolveCliContext(options)
 
   try {
-    while (argv[0] === '--') {
-      argv = argv.slice(1)
-    }
+    argv = stripLeadingSeparators(argv)
 
     let globalOptions = extractGlobalOptions(argv)
-    argv = globalOptions.argv
+    argv = stripLeadingSeparators(globalOptions.argv)
     configureColors({ disabled: globalOptions.noColor })
 
     if (argv.length === 0) {
@@ -50,40 +70,51 @@ export async function runRemix(
   }
 }
 
+function stripLeadingSeparators(argv: string[]): string[] {
+  while (argv[0] === '--') {
+    argv = argv.slice(1)
+  }
+
+  return argv
+}
+
 async function runCommand(command: string, argv: string[], context: CliContext): Promise<number> {
   if (command === 'help') {
     return runHelpCommand(argv)
   }
 
   if (command === '-v' || command === '--version') {
+    let { runVersionCommand } = await import('./commands/version.ts')
     return runVersionCommand([], context)
   }
 
   if (command === 'new') {
+    let { runNewCommand } = await import('./commands/new.ts')
     return runNewCommand(argv, context)
   }
 
   if (command === 'completion') {
+    let { runCompletionCommand } = await import('./commands/completion.ts')
     return runCompletionCommand(argv)
   }
 
   if (command === 'doctor') {
+    let { runDoctorCommand } = await import('./commands/doctor.ts')
     return runDoctorCommand(argv, context)
   }
 
-  if (command === 'skills') {
-    return runSkillsCommand(argv, context)
-  }
-
   if (command === 'routes') {
+    let { runRoutesCommand } = await import('./commands/routes.ts')
     return runRoutesCommand(argv, context)
   }
 
   if (command === 'test') {
+    let { runTestCommand } = await import('./commands/test.ts')
     return runTestCommand(argv, context)
   }
 
   if (command === 'version') {
+    let { runVersionCommand } = await import('./commands/version.ts')
     return runVersionCommand(argv, context)
   }
 

package/src/lib/commands/completion.ts

@@ -16,7 +16,7 @@ import { formatHelpText } from '../help-text.ts'
 import { parseArgs } from '../parse-args.ts'
 
 export async function runCompletionCommand(argv: string[]): Promise<number> {
-  if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+  if (argv.length === 0) {
     process.stdout.write(getCompletionCommandHelpText())
     return 0
   }
@@ -25,6 +25,11 @@ export async function runCompletionCommand(argv: string[]): Promise<number> {
     return runCompletionPlumbing(argv.slice(1))
   }
 
+  if (argv.includes('-h') || argv.includes('--help')) {
+    process.stdout.write(getCompletionCommandHelpText())
+    return 0
+  }
+
   let [shell, ...rest] = argv
 
   try {

package/src/lib/commands/doctor.ts

@@ -26,9 +26,9 @@ import {
 } from '../reporter.ts'
 
 const DOCTOR_SUITE_LABELS = {
-  controllers: {
-    complete: 'controllers',
-    running: 'Checking controllers',
+  actions: {
+    complete: 'actions',
+    running: 'Checking actions',
   },
   environment: {
     complete: 'environment',
@@ -109,7 +109,7 @@ export function getDoctorCommandHelpText(target: NodeJS.WriteStream = process.st
           description: 'Exit with status 1 when warning-level findings are present',
           label: '--strict',
         },
-        { description: 'Apply low-risk project and controller fixes', label: '--fix' },
+        { description: 'Apply low-risk project and action fixes', label: '--fix' },
       ],
       usage: ['remix doctor [--json] [--strict] [--fix] [--no-color]'],
     },
@@ -182,16 +182,13 @@ async function collectDoctorReport(
 
   if (hasWarningFindings(environment.suite.findings)) {
     let projectSuite = createSkippedDoctorSuite('project', 'Blocked by environment warnings.')
-    let controllersSuite = createSkippedDoctorSuite(
-      'controllers',
-      'Blocked by environment warnings.',
-    )
-    suites.push(projectSuite, controllersSuite)
+    let actionsSuite = createSkippedDoctorSuite('actions', 'Blocked by environment warnings.')
+    suites.push(projectSuite, actionsSuite)
     progress?.skip(projectSuite.name, projectSuite.reason)
     writeDoctorSuiteDetails(reporter, projectSuite)
     progress?.writeSummaryGap()
-    progress?.skip(controllersSuite.name, controllersSuite.reason)
-    writeDoctorSuiteDetails(reporter, controllersSuite)
+    progress?.skip(actionsSuite.name, actionsSuite.reason)
+    writeDoctorSuiteDetails(reporter, actionsSuite)
     progress?.writeSummaryGap()
 
     return {
@@ -240,10 +237,10 @@ async function collectDoctorReport(
   progress?.writeSummaryGap()
 
   if (hasWarningFindings(project.suite.findings)) {
-    let controllersSuite = createSkippedDoctorSuite('controllers', 'Blocked by project warnings.')
-    suites.push(controllersSuite)
-    progress?.skip(controllersSuite.name, controllersSuite.reason)
-    writeDoctorSuiteDetails(reporter, controllersSuite)
+    let actionsSuite = createSkippedDoctorSuite('actions', 'Blocked by project warnings.')
+    suites.push(actionsSuite)
+    progress?.skip(actionsSuite.name, actionsSuite.reason)
+    writeDoctorSuiteDetails(reporter, actionsSuite)
     progress?.writeSummaryGap()
 
     return {
@@ -256,7 +253,7 @@ async function collectDoctorReport(
     }
   }
 
-  let controllers = await runDoctorSuite(progress, 'controllers', async () => {
+  let actions = await runDoctorSuite(progress, 'actions', async () => {
     let controllerResult = await checkControllerConventions(
       project.routeManifest!.appRoot,
       project.routeManifest!.tree,
@@ -276,7 +273,7 @@ async function collectDoctorReport(
       remainingFindings = finalControllerResult.suite.findings
     }
 
-    let suite = createDoctorSuite('controllers', remainingFindings)
+    let suite = createDoctorSuite('actions', remainingFindings)
     if (suiteAppliedFixes.length > 0) {
       suite.appliedFixes = suiteAppliedFixes
     }
@@ -284,10 +281,10 @@ async function collectDoctorReport(
     return { appliedFixes: suiteAppliedFixes, suite }
   })
 
-  findings.push(...controllers.suite.findings)
-  appliedFixes.push(...(controllers.appliedFixes ?? []))
-  suites.push(controllers.suite)
-  writeDoctorSuiteDetails(reporter, controllers.suite)
+  findings.push(...actions.suite.findings)
+  appliedFixes.push(...(actions.appliedFixes ?? []))
+  suites.push(actions.suite)
+  writeDoctorSuiteDetails(reporter, actions.suite)
   progress?.writeSummaryGap()
 
   let report: DoctorReport = {

package/src/lib/commands/help.ts

@@ -1,18 +1,7 @@
 import * as process from 'node:process'
 
-import { getCompletionCommandHelpText } from './completion.ts'
 import { renderCliError, toCliError, unknownHelpTopic } from '../errors.ts'
 import { formatHelpText } from '../help-text.ts'
-import { getDoctorCommandHelpText } from './doctor.ts'
-import { getNewCommandHelpText } from './new.ts'
-import { getRoutesCommandHelpText } from './routes.ts'
-import {
-  getSkillsCommandHelpText,
-  getSkillsInstallCommandHelpText,
-  getSkillsListCommandHelpText,
-} from './skills.ts'
-import { getTestCommandHelpText } from './test.ts'
-import { getVersionCommandHelpText } from './version.ts'
 
 export async function runHelpCommand(argv: string[]): Promise<number> {
   if (argv.includes('-h') || argv.includes('--help')) {
@@ -21,7 +10,7 @@ export async function runHelpCommand(argv: string[]): Promise<number> {
   }
 
   try {
-    process.stdout.write(getCommandHelpText(argv))
+    process.stdout.write(await getCommandHelpText(argv))
     return 0
   } catch (error) {
     process.stderr.write(
@@ -40,7 +29,6 @@ export function getCliHelpText(target: NodeJS.WriteStream = process.stdout): str
         { description: 'Create a new Remix project', label: 'new <name>' },
         { description: 'Check project health for the current project', label: 'doctor' },
         { description: 'Show the route tree for the current project', label: 'routes' },
-        { description: 'Manage Remix skills for the current project', label: 'skills' },
         { description: 'Run tests for the current project', label: 'test [glob]' },
         { description: 'Show the current Remix version', label: 'version' },
       ],
@@ -49,12 +37,10 @@ export function getCliHelpText(target: NodeJS.WriteStream = process.stdout): str
         'remix help',
         'remix help completion',
         'remix help doctor',
-        'remix help skills install',
         'remix doctor',
         'remix new my-remix-app',
         'remix new my-remix-app --app-name "My Remix App"',
         'remix routes',
-        'remix skills install',
         'remix test',
         'remix version',
       ],
@@ -79,7 +65,6 @@ export function getHelpCommandHelpText(target: NodeJS.WriteStream = process.stdo
         'remix help doctor',
         'remix help new',
         'remix help routes',
-        'remix help skills install',
         'remix help test',
         'remix help version',
       ],
@@ -89,7 +74,7 @@ export function getHelpCommandHelpText(target: NodeJS.WriteStream = process.stdo
   )
 }
 
-function getCommandHelpText(argv: string[]): string {
+async function getCommandHelpText(argv: string[]): Promise<string> {
   if (argv.length === 0) {
     return getCliHelpText()
   }
@@ -101,30 +86,32 @@ function getCommandHelpText(argv: string[]): string {
   }
 
   if (command === 'new' && rest.length === 0) {
+    let { getNewCommandHelpText } = await import('./new.ts')
     return getNewCommandHelpText()
   }
 
   if (command === 'completion' && rest.length === 0) {
+    let { getCompletionCommandHelpText } = await import('./completion.ts')
     return getCompletionCommandHelpText()
   }
 
   if (command === 'doctor' && rest.length === 0) {
+    let { getDoctorCommandHelpText } = await import('./doctor.ts')
     return getDoctorCommandHelpText()
   }
 
   if (command === 'routes' && rest.length === 0) {
+    let { getRoutesCommandHelpText } = await import('./routes.ts')
     return getRoutesCommandHelpText()
   }
 
-  if (command === 'skills') {
-    return getSkillsHelpText(rest)
-  }
-
   if (command === 'test' && rest.length === 0) {
-    return getTestCommandHelpText()
+    let { getTestCommandHelpText } = await import('./test.ts')
+    return await getTestCommandHelpText()
   }
 
   if (command === 'version' && rest.length === 0) {
+    let { getVersionCommandHelpText } = await import('./version.ts')
     return getVersionCommandHelpText()
   }
 
@@ -134,24 +121,3 @@ function getCommandHelpText(argv: string[]): string {
 function getNestedHelpText(command: string, argv: string[]): string {
   throw unknownHelpTopic(`${command} ${argv.join(' ')}`)
 }
-
-function getSkillsHelpText(argv: string[]): string {
-  if (argv.length === 0) {
-    return getSkillsCommandHelpText()
-  }
-
-  let [subcommand, ...rest] = argv
-  if (rest.length > 0) {
-    throw unknownHelpTopic(`skills ${argv.join(' ')}`)
-  }
-
-  if (subcommand === 'install') {
-    return getSkillsInstallCommandHelpText()
-  }
-
-  if (subcommand === 'list') {
-    return getSkillsListCommandHelpText()
-  }
-
-  throw unknownHelpTopic(`skills ${argv.join(' ')}`)
-}

package/src/lib/commands/routes.ts

@@ -8,7 +8,7 @@ import { createCommandReporter, type TextChannel } from '../reporter.ts'
 import { loadRouteMap, type LoadedRouteMap, type RouteTreeNode } from '../route-map.ts'
 import { lightRed } from '../terminal.ts'
 
-const CONTROLLERS_PATH_PREFIX = 'app/controllers/'
+const ACTIONS_PATH_PREFIX = 'app/actions/'
 
 export async function runRoutesCommand(argv: string[], context: CliContext): Promise<number> {
   if (argv.includes('-h') || argv.includes('--help')) {
@@ -243,8 +243,8 @@ function colorRouteLine(line: string, node: RouteTreeNode): string {
 }
 
 function getCompactOwnerPath(ownerPath: string): string {
-  if (ownerPath.startsWith(CONTROLLERS_PATH_PREFIX)) {
-    return ownerPath.slice(CONTROLLERS_PATH_PREFIX.length)
+  if (ownerPath.startsWith(ACTIONS_PATH_PREFIX)) {
+    return ownerPath.slice(ACTIONS_PATH_PREFIX.length)
   }
 
   return ownerPath

package/src/lib/commands/test.ts

@@ -1,4 +1,3 @@
-import { getRemixTestHelpText, runRemixTest } from '@remix-run/test/cli'
 import * as process from 'node:process'
 
 import type { CliContext } from '../cli-context.ts'
@@ -6,20 +5,27 @@ import { renderCliError, toCliError } from '../errors.ts'
 
 export async function runTestCommand(argv: string[], context: CliContext): Promise<number> {
   if (argv.includes('-h') || argv.includes('--help')) {
-    process.stdout.write(`${getTestCommandHelpText()}\n`)
+    process.stdout.write(`${await getTestCommandHelpText()}\n`)
     return 0
   }
 
   try {
+    let { runRemixTest } = await import('@remix-run/test/cli')
     return await runRemixTest({ argv, cwd: context.cwd })
   } catch (error) {
+    let helpText = await getTestCommandHelpText(process.stderr)
     process.stderr.write(
-      renderCliError(toCliError(error), { helpText: getTestCommandHelpText(process.stderr) }),
+      renderCliError(toCliError(error), {
+        helpText,
+      }),
     )
     return 1
   }
 }
 
-export function getTestCommandHelpText(target: NodeJS.WriteStream = process.stdout): string {
+export async function getTestCommandHelpText(
+  target: NodeJS.WriteStream = process.stdout,
+): Promise<string> {
+  let { getRemixTestHelpText } = await import('@remix-run/test/cli')
   return getRemixTestHelpText(target)
 }