@wular/pnext 0.0.4 → 0.0.7

package/src/cli/index.ts

@@ -1,117 +1,126 @@
 #!/usr/bin/env bun
-import { existsSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { markBoot } from './boot-trace';
-import { commandBinaryName, nameEsbuildProcess, namedBunBinary } from './named-bin';
+import { existsSync, statSync } from 'node:fs'
+import path from 'node:path'
+import { markBoot } from './boot/trace'
+import { commandBinaryName, nameEsbuildProcess, namedBunBinary } from './boot/named-bin'
+
+// Reached only if something bypassed bin/pnext (which guards the same way).
+if (typeof Bun === 'undefined') {
+  console.error('pnext requires Bun. Install it from https://bun.sh/get')
+  process.exit(1)
+}
 
-const [, , command, ...args] = process.argv;
-markBoot('cli:entry');
+const [, , command, ...args] = process.argv
+markBoot('cli:entry')
 
 // A no-op once we already run under the command's name; otherwise it creates
 // the hardlink so bin/pnext can exec it directly from the next run on.
-namedBunBinary(commandBinaryName(command));
+namedBunBinary(commandBinaryName(command))
 
 // Before any command lazily imports esbuild, which captures the binary path on
 // module load.
-nameEsbuildProcess();
-markBoot('cli:naming');
+nameEsbuildProcess()
+markBoot('cli:naming')
 
 try {
   if (command === 'dev') {
-    const { dev } = await import('./dev');
+    const { dev } = await import('./dev')
     await dev({
       root: positionalRoot(args),
       port: optionNumber(args, '--port'),
       hostname: optionString(args, '--hostname'),
-    });
+    })
   } else if (command === 'build') {
-    const { buildProject } = await import('./build');
+    const { buildProject } = await import('./build')
     await buildProject(positionalRoot(args), {
       adapter: adapterOption(args),
       verbose: args.includes('--verbose'),
       debugBuildPaths: optionString(args, '--debug-build-paths'),
       buildMode: buildModeOption(args),
       debugPrerender: args.includes('--debug-prerender'),
-    });
+    })
     // A live CSS worker thread races Bun's exit teardown (Linux: silent exit 1
     // after a successful build); stop it before force-exiting.
-    await (await import('../css/build')).stopCssWorker();
+    await (await import('../css/build')).stopCssWorker()
     // Nothing here keeps the event loop alive on success, but a project's
     // next.config can (e.g. a stray setInterval) and Next's own `next build`
     // force-exits regardless of such handles. Do the same so `build` always
     // terminates once buildProject resolves.
-    process.exit(0);
+    process.exit(0)
   } else if (command === 'start') {
-    const root = positionalRoot(args);
+    const root = positionalRoot(args)
     // The build emits src/cli/start.ts prebundled into one file; parsing that
     // instead of walking the framework's source graph is most of `start`'s
     // spawn→first-200. Absent (no build yet, custom outDir) → source path.
-    const { prebuiltServerEntry } = await import('./server-entry');
-    const prebuilt = prebuiltServerEntry(root);
+    const { prebuiltServerEntry } = await import('./serve/entry')
+    const prebuilt = prebuiltServerEntry(root)
     const { start } = prebuilt
       ? ((await import(prebuilt)) as typeof import('./start'))
-      : await import('./start');
+      : await import('./start')
     await start({
       root,
       port: optionNumber(args, '--port'),
       hostname: optionString(args, '--hostname'),
-    });
+    })
   } else if (command === 'analyze') {
-    const { analyzeProject } = await import('./analyze');
-    const { route, root } = analyzePositionals(args);
+    const { analyzeProject } = await import('./analyze')
+    const { route, root } = analyzePositionals(args)
     const result = await analyzeProject(root, {
       compression: analyzeCompression(args),
       route,
-    });
+    })
     if (args.includes('--json')) {
-      console.log(JSON.stringify(result, null, 2));
+      console.log(JSON.stringify(result, null, 2))
     } else {
-      const { printAnalyzeResult } = await import('./analyze-print');
-      printAnalyzeResult(result, { route, files: args.includes('--files') });
+      const { printAnalyzeResult } = await import('./analyze')
+      printAnalyzeResult(result, { route, files: args.includes('--files') })
     }
   } else if (command === 'typegen') {
-    const { typegenProject } = await import('../typegen');
-    const result = await typegenProject(positionalRoot(args));
+    const { typegenProject } = await import('./typegen')
+    const result = await typegenProject(positionalRoot(args))
     console.log(
       `Generated ${result.routes} route types, ${result.aliases} aliases, and ${result.checks} checks at ${result.file}`,
-    );
+    )
     // Like `next typegen`, exit even when the loaded next.config leaves open
     // handles (timers/connections) alive — a one-shot command must not hang.
-    process.exit(0);
+    process.exit(0)
   } else if (command === 'create') {
-    const { createApp } = await import('./create');
-    await createApp(positionals(args)[0], { install: !args.includes('--no-install') });
-    process.exit(0);
+    const { createApp } = await import('./create')
+    await createApp(positionals(args)[0], { install: !args.includes('--no-install') })
+    process.exit(0)
   } else if (command === 'migrate') {
-    const { migrateApp } = await import('./migrate');
-    const code = await migrateApp(positionalRoot(args), { dryRun: args.includes('--dry-run') });
-    process.exit(code);
+    const { migrateApp } = await import('./migrate/run')
+    const code = await migrateApp(positionalRoot(args), { dryRun: args.includes('--dry-run') })
+    process.exit(code)
   } else {
-    printHelp();
-    process.exit(command ? 1 : 0);
+    printHelp()
+    process.exit(command ? 1 : 0)
   }
 } catch (error) {
-  const formatted = formatCliError(error);
+  const formatted = formatCliError(error)
   // A blank formatted message exits 1 with no explanation; fall back to the
   // raw error so the failure is never silent.
-  if (formatted.message.trim()) console.error(formatted.message);
-  else console.error(error instanceof Error ? (error.stack ?? `${error.name}: ${error.message}`) : String(error));
-  if (formatted.trace) console.log(`\n${formatted.trace}`);
-  process.exit(1);
+  if (formatted.message.trim()) console.error(formatted.message)
+  else
+    console.error(
+      error instanceof Error ? (error.stack ?? `${error.name}: ${error.message}`) : String(error),
+    )
+  if (formatted.trace) console.log(`\n${formatted.trace}`)
+  process.exit(1)
 }
 
 function formatCliError(error: unknown) {
-  const message = error instanceof Error ? error.message : String(error);
-  const traceStart = message.indexOf('\npnext client import trace for route ');
-  if (traceStart === -1) return { message };
+  const message = error instanceof Error ? error.message : String(error)
+  const traceStart = message.indexOf('\npnext client import trace for route ')
+  if (traceStart === -1) return { message }
   return {
     message: message.slice(0, traceStart),
     trace: message.slice(traceStart + 1),
-  };
+  }
 }
 
 function positionalRoot(args: string[]) {
-  return positionals(args)[0];
+  return positionals(args)[0]
 }
 
 // The analyze command takes optional [route] and [directory] positionals. A
@@ -119,27 +128,27 @@ function positionalRoot(args: string[]) {
 // that looks like a project root — system directories like /home or /run
 // collide with real route names.
 function analyzePositionals(args: string[]) {
-  let route: string | undefined;
-  let root: string | undefined;
+  let route: string | undefined
+  let root: string | undefined
   for (const arg of positionals(args)) {
-    if (!route && arg.startsWith('/') && !isProjectDirectory(arg)) route = arg;
-    else root ??= arg;
+    if (!route && arg.startsWith('/') && !isProjectDirectory(arg)) route = arg
+    else root ??= arg
   }
-  return { route, root };
+  return { route, root }
 }
 
 function isProjectDirectory(candidate: string) {
-  if (!isDirectory(candidate)) return false;
+  if (!isDirectory(candidate)) return false
   return ['package.json', '.pnext', 'app', path.join('src', 'app')].some(entry =>
     existsSync(path.join(candidate, entry)),
-  );
+  )
 }
 
 function positionals(args: string[]) {
-  const out: string[] = [];
+  const out: string[] = []
   for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (!arg) continue;
+    const arg = args[index]
+    if (!arg) continue
     if (
       arg === '--port' ||
       arg === '--adapter' ||
@@ -147,36 +156,36 @@ function positionals(args: string[]) {
       arg === '--debug-build-paths' ||
       arg === '--experimental-build-mode'
     ) {
-      index += 1;
-      continue;
+      index += 1
+      continue
     }
-    if (!arg.startsWith('--')) out.push(arg);
+    if (!arg.startsWith('--')) out.push(arg)
   }
-  return out;
+  return out
 }
 
 function isDirectory(candidate: string) {
   try {
-    return statSync(candidate).isDirectory();
+    return statSync(candidate).isDirectory()
   } catch {
-    return false;
+    return false
   }
 }
 
 function optionNumber(args: string[], name: string) {
-  const index = args.indexOf(name);
-  if (index === -1) return undefined;
-  const value = args[index + 1];
-  return value ? Number(value) : undefined;
+  const index = args.indexOf(name)
+  if (index === -1) return undefined
+  const value = args[index + 1]
+  return value ? Number(value) : undefined
 }
 
 function optionString(args: string[], name: string) {
   // Accept both `--name value` and `--name=value`.
-  const inline = args.find(arg => arg.startsWith(`${name}=`));
-  if (inline !== undefined) return inline.slice(name.length + 1);
-  const index = args.indexOf(name);
-  if (index === -1) return undefined;
-  return args[index + 1];
+  const inline = args.find(arg => arg.startsWith(`${name}=`))
+  if (inline !== undefined) return inline.slice(name.length + 1)
+  const index = args.indexOf(name)
+  if (index === -1) return undefined
+  return args[index + 1]
 }
 
 /**
@@ -186,27 +195,27 @@ function optionString(args: string[], name: string) {
  * the standard full build (idempotent over a prior `compile` run).
  */
 function buildModeOption(args: string[]): 'compile' | 'generate' | undefined {
-  const value = optionString(args, '--experimental-build-mode');
-  if (value === 'compile' || value === 'generate') return value;
+  const value = optionString(args, '--experimental-build-mode')
+  if (value === 'compile' || value === 'generate') return value
   if (value !== undefined) {
     console.error(
       `error: option '--experimental-build-mode <mode>' argument '${value}' is invalid. Expected 'compile' or 'generate'.`,
-    );
-    process.exit(1);
+    )
+    process.exit(1)
   }
-  return undefined;
+  return undefined
 }
 
 function adapterOption(args: string[]) {
-  const index = args.indexOf('--adapter');
-  if (index === -1) return undefined;
-  const adapter = args[index + 1];
-  if (adapter === 'vercel') return adapter;
-  throw new Error(`Unsupported adapter: ${adapter ?? ''}`);
+  const index = args.indexOf('--adapter')
+  if (index === -1) return undefined
+  const adapter = args[index + 1]
+  if (adapter === 'vercel') return adapter
+  throw new Error(`Unsupported adapter: ${adapter ?? ''}`)
 }
 
 function analyzeCompression(args: string[]) {
-  return args.includes('--brotli') ? 'brotli' : 'gzip';
+  return args.includes('--brotli') ? 'brotli' : 'gzip'
 }
 
 function printHelp() {
@@ -216,5 +225,5 @@ pnext start [directory] [--port 3000] [--hostname 127.0.0.1]
 pnext analyze [route] [directory] [--brotli] [--files] [--json]
 pnext typegen [directory]
 pnext create <directory> [--no-install]
-pnext migrate [directory] [--dry-run]`);
+pnext migrate [directory] [--dry-run]`)
 }

package/src/cli/migrate/package-json.ts

@@ -1,15 +1,16 @@
 // package.json rewriting: scripts and dependencies. Structured edit only —
 // JSON.parse -> mutate -> stringify, which preserves key insertion order.
 
-import { readFile, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import type { MigrationResult } from './report';
+import { readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { pnextVersionRange } from '../../utils/fs'
+import type { MigrationResult } from './report'
 
-const SEPARATORS = new Set(['&&', '||', ';', '|', '&']);
-const MAPPED_SUBCOMMANDS = new Set(['dev', 'build', 'start', 'typegen']);
-const DROPPED_FLAGS = new Set(['--turbo', '--turbopack']);
+const SEPARATORS = new Set(['&&', '||', ';', '|', '&'])
+const MAPPED_SUBCOMMANDS = new Set(['dev', 'build', 'start', 'typegen'])
+const DROPPED_FLAGS = new Set(['--turbo', '--turbopack'])
 
-type Json = Record<string, unknown>;
+type Json = Record<string, unknown>
 
 /**
  * Rewrite `next` only where it is a command word: the first token of the
@@ -17,64 +18,64 @@ type Json = Record<string, unknown>;
  * `nextron build` or `npx next-sitemap` are never touched.
  */
 export function rewriteScript(script: string): { script: string; reports: string[] } {
-  const tokens = script.split(/\s+/).filter(Boolean);
-  const reports: string[] = [];
-  const out: string[] = [];
-  let commandStart = true;
-  let changed = false;
+  const tokens = script.split(/\s+/).filter(Boolean)
+  const reports: string[] = []
+  const out: string[] = []
+  let commandStart = true
+  let changed = false
 
   for (let index = 0; index < tokens.length; index += 1) {
-    const token = tokens[index]!;
+    const token = tokens[index]!
     if (SEPARATORS.has(token)) {
-      out.push(token);
-      commandStart = true;
-      continue;
+      out.push(token)
+      commandStart = true
+      continue
     }
     // Env-var prefixes (NODE_OPTIONS=x next dev) don't end the command position.
     if (commandStart && /^[A-Za-z_][A-Za-z0-9_]*=/.test(token)) {
-      out.push(token);
-      continue;
+      out.push(token)
+      continue
     }
     if (!commandStart || token !== 'next') {
-      out.push(token);
-      commandStart = false;
-      continue;
+      out.push(token)
+      commandStart = false
+      continue
     }
 
-    let end = index + 1;
-    while (end < tokens.length && !SEPARATORS.has(tokens[end]!)) end += 1;
-    const subcommand = tokens[index + 1];
-    const rest = tokens.slice(index + 2, end);
+    let end = index + 1
+    while (end < tokens.length && !SEPARATORS.has(tokens[end]!)) end += 1
+    const subcommand = tokens[index + 1]
+    const rest = tokens.slice(index + 2, end)
 
     if (subcommand && MAPPED_SUBCOMMANDS.has(subcommand)) {
-      out.push('pnext', subcommand, ...translateFlags(subcommand, rest));
-      changed = true;
+      out.push('pnext', subcommand, ...translateFlags(subcommand, rest))
+      changed = true
     } else if (subcommand === 'lint') {
-      out.push(...tokens.slice(index, end));
-      reports.push('`next lint` left as-is — pnext has no lint command; run eslint directly.');
+      out.push(...tokens.slice(index, end))
+      reports.push('`next lint` left as-is — pnext has no lint command; run eslint directly.')
     } else {
-      out.push(...tokens.slice(index, end));
-      const command = subcommand ? `next ${subcommand}` : 'next';
-      reports.push(`\`${command}\` has no pnext equivalent — left as-is.`);
+      out.push(...tokens.slice(index, end))
+      const command = subcommand ? `next ${subcommand}` : 'next'
+      reports.push(`\`${command}\` has no pnext equivalent — left as-is.`)
     }
-    index = end - 1;
-    commandStart = false;
+    index = end - 1
+    commandStart = false
   }
 
-  return { script: changed ? out.join(' ') : script, reports };
+  return { script: changed ? out.join(' ') : script, reports }
 }
 
 function translateFlags(subcommand: string, rest: string[]) {
-  const out: string[] = [];
+  const out: string[] = []
   for (const flag of rest) {
-    if (DROPPED_FLAGS.has(flag)) continue;
+    if (DROPPED_FLAGS.has(flag)) continue
     if (flag === '-p' && (subcommand === 'dev' || subcommand === 'start')) {
-      out.push('--port');
-      continue;
+      out.push('--port')
+      continue
     }
-    out.push(flag);
+    out.push(flag)
   }
-  return out;
+  return out
 }
 
 export async function migratePackageJson(
@@ -83,18 +84,18 @@ export async function migratePackageJson(
   result: MigrationResult,
   dryRun: boolean,
 ) {
-  const scripts = isObject(pkg.scripts) ? pkg.scripts : undefined;
+  const scripts = isObject(pkg.scripts) ? pkg.scripts : undefined
   if (scripts) {
-    const rewritten: string[] = [];
+    const rewritten: string[] = []
     for (const [name, value] of Object.entries(scripts)) {
-      if (typeof value !== 'string') continue;
-      const { script, reports } = rewriteScript(value);
+      if (typeof value !== 'string') continue
+      const { script, reports } = rewriteScript(value)
       if (script !== value) {
-        scripts[name] = script;
-        rewritten.push(`${name}: ${value} → ${script}`);
+        scripts[name] = script
+        rewritten.push(`${name}: ${value} → ${script}`)
       }
       for (const detail of reports) {
-        result.reports.push({ title: `package.json script "${name}"`, detail });
+        result.reports.push({ title: `package.json script "${name}"`, detail })
       }
     }
     if (rewritten.length > 0) {
@@ -102,82 +103,83 @@ export async function migratePackageJson(
         file: 'package.json',
         description: `scripts rewritten (${rewritten.length})`,
         details: rewritten,
-      });
+      })
     }
   }
 
-  const dependencies = ensureObject(pkg, 'dependencies');
-  const devDependencies = ensureObject(pkg, 'devDependencies');
+  const dependencies = ensureObject(pkg, 'dependencies')
+  const devDependencies = ensureObject(pkg, 'devDependencies')
 
   for (const [field, bucket] of [
     ['dependencies', dependencies],
     ['devDependencies', devDependencies],
   ] as const) {
     if ('next' in bucket) {
-      delete bucket.next;
+      delete bucket.next
       result.edits.push({
         file: 'package.json',
         description: 'next removed',
         details: [`next removed from ${field}`],
-      });
+      })
     }
   }
   if (!('@wular/pnext' in devDependencies) && !('@wular/pnext' in dependencies)) {
-    devDependencies['@wular/pnext'] = '^0.0.1';
+    const versionRange = pnextVersionRange()
+    devDependencies['@wular/pnext'] = versionRange
     result.edits.push({
       file: 'package.json',
       description: '@wular/pnext added',
-      details: ['devDependencies: @wular/pnext ^0.0.1'],
-    });
+      details: [`devDependencies: @wular/pnext ${versionRange}`],
+    })
   }
   if (!('preact' in dependencies) && !('preact' in devDependencies)) {
-    dependencies.preact = '^10';
+    dependencies.preact = '^10'
     result.edits.push({
       file: 'package.json',
       description: 'preact added',
       details: ['dependencies: preact ^10 (react/react-dom kept — compat aliases them)'],
-    });
+    })
   }
 
   const leftovers = [...Object.keys(dependencies), ...Object.keys(devDependencies)].filter(
     name => name === 'eslint-config-next' || name.startsWith('@next/'),
-  );
+  )
   if (leftovers.length > 0) {
     result.reports.push({
       title: 'Next-specific packages still installed',
       detail: 'Optional cleanup — these are unused under pnext. See reference/compat.md.',
       files: leftovers,
-    });
+    })
   }
 
-  pruneEmpty(pkg, 'dependencies');
-  pruneEmpty(pkg, 'devDependencies');
+  pruneEmpty(pkg, 'dependencies')
+  pruneEmpty(pkg, 'devDependencies')
 
   if (!dryRun) {
-    await writeFile(path.join(root, 'package.json'), `${JSON.stringify(pkg, null, 2)}\n`);
+    await writeFile(path.join(root, 'package.json'), `${JSON.stringify(pkg, null, 2)}\n`)
   }
 }
 
 export async function readPackageJson(root: string): Promise<Json | undefined> {
   try {
-    const parsed = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8')) as unknown;
-    return isObject(parsed) ? parsed : undefined;
+    const parsed = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8')) as unknown
+    return isObject(parsed) ? parsed : undefined
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
 function isObject(value: unknown): value is Json {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
 // Create the bucket in place so an existing key keeps its position.
 function ensureObject(pkg: Json, key: string): Json {
-  if (!isObject(pkg[key])) pkg[key] = {};
-  return pkg[key] as Json;
+  if (!isObject(pkg[key])) pkg[key] = {}
+  return pkg[key] as Json
 }
 
 function pruneEmpty(pkg: Json, key: string) {
-  const value = pkg[key];
-  if (isObject(value) && Object.keys(value).length === 0) delete pkg[key];
+  const value = pkg[key]
+  if (isObject(value) && Object.keys(value).length === 0) delete pkg[key]
 }