@rebasepro/cli 0.18.1 → 0.19.0

package/dist/commands/normalize-imports.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Give compiled output the relative-import extensions Node's ESM loader needs.
+ *
+ * ## Why a project needs this at all
+ *
+ * TypeScript does not rewrite module specifiers, deliberately and by long-stated
+ * policy: what you write is what it emits. Node's ESM loader, equally
+ * deliberately, resolves no extensions — `./authors` is not a module, only
+ * `./authors.js` is. Between those two positions sits every project that writes
+ * extensionless relative imports, which is most of them, and which
+ * `moduleResolution: "bundler"` — what this scaffold ships — is designed for.
+ *
+ * The usual escape is to write the *output* extension in the *source*:
+ * `import x from "./authors.js"` in a file called `authors.ts`. It works, and it
+ * is a tax on every import in the project to satisfy a step the toolchain could
+ * take itself. This is that step.
+ *
+ * ## Why it is a command
+ *
+ * `rebase build` has always done this to its own bundle — the specifiers in
+ * `dist-bundle` are complete because {@link normalizeEsmSpecifiers} completes
+ * them. Nothing did it for the plain `tsc` output that `rebase eject` runs
+ * (`node dist/backend/src/index.js`) or that a self-hoster runs after
+ * `pnpm build`. So the templates wrote `.js` in source, which is the tax, and
+ * removing it silently broke eject at `pnpm start` while `check:eject` — which
+ * typechecks with `noEmit` — stayed green.
+ *
+ * One implementation, on both paths, callable from a package.json script.
+ *
+ * Mechanical and verifiable: only relative specifiers are touched, and only when
+ * the target resolves to a file that exists. Idempotent, so a build that runs it
+ * twice is a build that runs it once.
+ */
+export declare const NORMALIZE_IMPORTS_FLAGS: {
+    /** Report what would change without writing anything. */
+    readonly "--check": BooleanConstructor;
+};
+export declare function normalizeImportsCommand(rawArgs: string[]): Promise<void>;

package/dist/index.es.js

@@ -10838,6 +10838,98 @@ async function statusCommand$1(rawArgs) {
 	console.log("");
 }
 //#endregion
+//#region src/commands/normalize-imports.ts
+/**
+* Give compiled output the relative-import extensions Node's ESM loader needs.
+*
+* ## Why a project needs this at all
+*
+* TypeScript does not rewrite module specifiers, deliberately and by long-stated
+* policy: what you write is what it emits. Node's ESM loader, equally
+* deliberately, resolves no extensions — `./authors` is not a module, only
+* `./authors.js` is. Between those two positions sits every project that writes
+* extensionless relative imports, which is most of them, and which
+* `moduleResolution: "bundler"` — what this scaffold ships — is designed for.
+*
+* The usual escape is to write the *output* extension in the *source*:
+* `import x from "./authors.js"` in a file called `authors.ts`. It works, and it
+* is a tax on every import in the project to satisfy a step the toolchain could
+* take itself. This is that step.
+*
+* ## Why it is a command
+*
+* `rebase build` has always done this to its own bundle — the specifiers in
+* `dist-bundle` are complete because {@link normalizeEsmSpecifiers} completes
+* them. Nothing did it for the plain `tsc` output that `rebase eject` runs
+* (`node dist/backend/src/index.js`) or that a self-hoster runs after
+* `pnpm build`. So the templates wrote `.js` in source, which is the tax, and
+* removing it silently broke eject at `pnpm start` while `check:eject` — which
+* typechecks with `noEmit` — stayed green.
+*
+* One implementation, on both paths, callable from a package.json script.
+*
+* Mechanical and verifiable: only relative specifiers are touched, and only when
+* the target resolves to a file that exists. Idempotent, so a build that runs it
+* twice is a build that runs it once.
+*/
+var NORMALIZE_IMPORTS_FLAGS = { 
+/** Report what would change without writing anything. */
+"--check": Boolean };
+var HELP = `
+${chalk.bold("rebase normalize-imports")} — complete the relative imports in compiled output
+
+${chalk.green.bold("Usage")}
+  rebase normalize-imports ${chalk.blue("<dir>")} [--check]
+
+${chalk.green.bold("What it does")}
+  TypeScript emits your module specifiers verbatim, and Node's ESM loader does
+  not guess extensions — so \`./authors\` compiles fine and fails at run time.
+  This rewrites each relative specifier in the emitted JavaScript to the file it
+  actually resolves to, so your source can stay extensionless.
+
+  Only relative specifiers, only when the target exists on disk, and idempotent.
+
+${chalk.green.bold("Arguments")}
+  ${chalk.blue("<dir>")}                   The directory tsc emitted into, e.g. ${chalk.cyan("dist")}
+
+${chalk.green.bold("Options")}
+  ${chalk.blue("--check")}                 Report what would change and exit 1 if anything would
+                          ${chalk.gray("(for CI — the build itself should just run the rewrite)")}
+
+${chalk.green.bold("Where it runs")}
+  The scaffold's ${chalk.cyan("config")} and ${chalk.cyan("backend")} build scripts, after ${chalk.cyan("tsc")}.
+  ${chalk.cyan("rebase build")} already does the same to the bundle it writes.
+`;
+async function normalizeImportsCommand(rawArgs) {
+	const { flags, positionals, help } = parseCommandArgs({
+		spec: NORMALIZE_IMPORTS_FLAGS,
+		rawArgs,
+		commandWords: 1,
+		command: "normalize-imports",
+		maxPositionals: 1
+	});
+	if (help) {
+		console.log(HELP);
+		return;
+	}
+	const target = positionals[0] ?? "dist";
+	const outDir = path.resolve(process.cwd(), target);
+	if (!fs.existsSync(outDir)) throw new Error(`${target} does not exist — run your build first. This step rewrites what the compiler emitted; it does not compile.`);
+	const { rewritten, unresolved } = normalizeEsmSpecifiers(outDir);
+	if (unresolved.length > 0) {
+		console.log(chalk.yellow(`  ⚠ ${unresolved.length} relative import(s) resolve to no file:`));
+		for (const specifier of unresolved.slice(0, 10)) console.log(chalk.dim(`      ${specifier}`));
+		if (unresolved.length > 10) console.log(chalk.dim(`      …and ${unresolved.length - 10} more`));
+		console.log(chalk.dim("    These will throw ERR_MODULE_NOT_FOUND at run time."));
+	}
+	if (flags["--check"]) {
+		if (rewritten > 0 || unresolved.length > 0) throw new Error(`${rewritten} import(s) are incomplete for Node ESM. Run \`rebase normalize-imports ${target}\` as part of the build.`);
+		console.log(chalk.green(`✓ every relative import in ${target} is complete`));
+		return;
+	}
+	console.log(rewritten > 0 ? chalk.dim(`  completed ${rewritten} relative import(s) in ${target}/ for Node ESM`) : chalk.dim(`  ${target}/ — every relative import was already complete`));
+}
+//#endregion
 //#region src/commands/skills.ts
 var require = createRequire(import.meta.url);
 /**
@@ -19014,6 +19106,9 @@ async function entry(args) {
 		case "dev":
 			await devCommand(args);
 			break;
+		case "normalize-imports":
+			await normalizeImportsCommand(args);
+			break;
 		case "build":
 			await buildCommand(args);
 			break;
@@ -19065,6 +19160,7 @@ ${chalk.green.bold("Commands")}
   ${chalk.blue.bold("init")}                    Create a new Rebase project
   ${chalk.blue.bold("dev")}                     Start the development server
   ${chalk.blue.bold("build")}                   Build the apps declared in rebase.json into a bundle
+  ${chalk.blue.bold("normalize-imports")}       Complete compiled output's relative imports for Node ESM
   ${chalk.blue.bold("start")}                   Start the backend server ${chalk.gray("(production)")}
   ${chalk.blue.bold("apps list")}               Show the apps this repository declares