@karmaniverous/smoz 0.2.14 → 0.2.15

package/dist/cli/{index.cjs → index.mjs}

@@ -1,20 +1,17 @@
 #!/usr/bin/env node
-'use strict';
+import { createCli } from '@karmaniverous/get-dotenv/cli';
+import { awsPlugin, cmdPlugin, batchPlugin } from '@karmaniverous/get-dotenv/plugins';
+import { definePlugin } from '@karmaniverous/get-dotenv/cliHost';
+import { packageDirectorySync } from 'package-directory';
+import fs, { existsSync, promises, readFileSync } from 'node:fs';
+import path, { join, posix, sep, dirname, relative, resolve } from 'node:path';
+import chokidar from 'chokidar';
+import { spawn, spawnSync } from 'node:child_process';
+import { buildSpawnEnv } from '@karmaniverous/get-dotenv';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { stdout, stdin } from 'node:process';
+import { createInterface } from 'node:readline/promises';
 
-var cli = require('@karmaniverous/get-dotenv/cli');
-var plugins = require('@karmaniverous/get-dotenv/plugins');
-var cliHost = require('@karmaniverous/get-dotenv/cliHost');
-var packageDirectory = require('package-directory');
-var fs = require('node:fs');
-var path = require('node:path');
-var chokidar = require('chokidar');
-var node_child_process = require('node:child_process');
-var getDotenv = require('@karmaniverous/get-dotenv');
-var node_url = require('node:url');
-var node_process = require('node:process');
-var promises = require('node:readline/promises');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 /**
  * SMOZ CLI: add
  *
@@ -39,7 +36,7 @@ const HTTP_METHODS = new Set([
     'options',
     'trace',
 ]);
-const toPosix$2 = (p) => p.split(path.sep).join('/');
+const toPosix$2 = (p) => p.split(sep).join('/');
 const formatMaybe$1 = async (root, filePath, source) => {
     try {
         const prettier = (await import('prettier'));
@@ -51,10 +48,10 @@ const formatMaybe$1 = async (root, filePath, source) => {
     }
 };
 const writeIfAbsent$1 = async (outFile, content) => {
-    if (fs.existsSync(outFile))
+    if (existsSync(outFile))
         return { created: false };
-    await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
-    await fs.promises.writeFile(outFile, content, 'utf8');
+    await promises.mkdir(dirname(outFile), { recursive: true });
+    await promises.writeFile(outFile, content, 'utf8');
     return { created: true };
 };
 /** True if a segment encodes a path param (:id | {id} | [id]). */
@@ -202,10 +199,10 @@ const runAdd = async (root, spec) => {
     // Derive path template and param names for OpenAPI hints
     const paramNames = baseParts.filter(isParamSeg).map(getParamName);
     const pathTemplate = '/' + pathSegs.join('/');
-    const dir = path.join(root, 'app', 'functions', token, ...dirSegs, ...(method ? [method] : []));
-    const lambdaPath = path.join(dir, 'lambda.ts');
-    const handlerPath = path.join(dir, 'handler.ts');
-    const openapiPath = path.join(dir, 'openapi.ts');
+    const dir = join(root, 'app', 'functions', token, ...dirSegs, ...(method ? [method] : []));
+    const lambdaPath = join(dir, 'lambda.ts');
+    const handlerPath = join(dir, 'handler.ts');
+    const openapiPath = join(dir, 'openapi.ts');
     // Compute contents
     const files = [];
     if (isHttp) {
@@ -250,9 +247,9 @@ const runAdd = async (root, spec) => {
         const formatted = await formatMaybe$1(root, f.path, f.content);
         const { created: c } = await writeIfAbsent$1(f.path, formatted);
         if (c)
-            created.push(path.posix.normalize(f.path));
+            created.push(posix.normalize(f.path));
         else
-            skipped.push(path.posix.normalize(f.path));
+            skipped.push(posix.normalize(f.path));
     }
     return { created, skipped };
 };
@@ -307,7 +304,7 @@ const launchOffline = async (root, opts) => {
 const spawnOffline = async (root, cmd, verbose) => {
     // Normalize child environment via get-dotenv when available; safe fallback otherwise.
     const baseEnv = { ...process.env };
-    const childEnv = getDotenv.buildSpawnEnv(baseEnv);
+    const childEnv = buildSpawnEnv(baseEnv);
     // Optional diagnostics to verify the child sees sane temp-related envs
     if (verbose) {
         const snap = {
@@ -320,7 +317,7 @@ const spawnOffline = async (root, cmd, verbose) => {
         };
         process.stdout.write(`[offline] env snapshot: ${JSON.stringify(snap)}\n`);
     }
-    const child = node_child_process.spawn(cmd.cmd, cmd.args, {
+    const child = spawn(cmd.cmd, cmd.args, {
         cwd: root,
         shell: cmd.shell,
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -364,7 +361,7 @@ const spawnOffline = async (root, cmd, verbose) => {
 const findTsxCli = (root) => {
     // Prefer invoking the JS entry to avoid shell .cmd quirks on Windows.
     const js = path.resolve(root, 'node_modules', 'tsx', 'dist', 'cli.js');
-    if (fs.existsSync(js)) {
+    if (existsSync(js)) {
         return {
             cmd: process.execPath,
             args: [js, 'app/config/openapi.ts'],
@@ -377,7 +374,7 @@ const findTsxCli = (root) => {
 };
 const findPrettierCli = (root) => {
     const js = path.resolve(root, 'node_modules', 'prettier', 'bin', 'prettier.cjs');
-    if (!fs.existsSync(js)) {
+    if (!existsSync(js)) {
         throw new Error(`prettier not found at ${js}. Install it as a devDependency.`);
     }
     return {
@@ -391,21 +388,21 @@ const runOpenapi = async (root, opts) => {
     const outFile = path.resolve(root, 'app', 'generated', 'openapi.json');
     let before;
     try {
-        if (fs.existsSync(outFile))
-            before = fs.readFileSync(outFile, 'utf8');
+        if (existsSync(outFile))
+            before = readFileSync(outFile, 'utf8');
     }
     catch {
         // ignore read errors; treat as absent
         before = undefined;
     }
     // Build a normalized child env via get-dotenv (static import).
-    const env = getDotenv.buildSpawnEnv({});
+    const env = buildSpawnEnv({});
     // Step 1: generate the OpenAPI spec.
     const tsx = findTsxCli(root);
     if (opts?.verbose) {
         console.log(`[openapi] ${[tsx.cmd, ...tsx.args].join(' ')}`);
     }
-    const genRes = node_child_process.spawnSync(tsx.cmd, tsx.args, {
+    const genRes = spawnSync(tsx.cmd, tsx.args, {
         cwd: root,
         stdio: 'inherit',
         shell: tsx.shell,
@@ -425,7 +422,7 @@ const runOpenapi = async (root, opts) => {
     if (opts?.verbose) {
         console.log(`[openapi] ${[prettier.cmd, ...prettier.args].join(' ')}`);
     }
-    const fmtRes = node_child_process.spawnSync(prettier.cmd, prettier.args, {
+    const fmtRes = spawnSync(prettier.cmd, prettier.args, {
         cwd: root,
         stdio: 'inherit',
         shell: prettier.shell,
@@ -442,9 +439,9 @@ const runOpenapi = async (root, opts) => {
     }
     // Determine whether the file content changed
     try {
-        if (!fs.existsSync(outFile))
+        if (!existsSync(outFile))
             return before !== undefined; // deleted vs existed
-        const after = fs.readFileSync(outFile, 'utf8');
+        const after = readFileSync(outFile, 'utf8');
         return before === undefined ? true : after !== before;
     }
     catch {
@@ -464,7 +461,7 @@ const runOpenapi = async (root, opts) => {
  *
  * Idempotent and formatted (uses Prettier if available).
  */
-const toPosix$1 = (p) => p.split(path.sep).join('/');
+const toPosix$1 = (p) => p.split(sep).join('/');
 const withoutTsExt = (p) => p.endsWith('.ts') ? p.slice(0, -3) : p;
 const HEADER = `/* AUTO-GENERATED by smoz register — DO NOT EDIT */
 `;
@@ -481,21 +478,21 @@ const formatMaybe = async (root, filePath, source) => {
 };
 const writeIfChanged = async (outFile, content) => {
     try {
-        const prev = await fs.promises.readFile(outFile, 'utf8');
+        const prev = await promises.readFile(outFile, 'utf8');
         if (prev === content)
             return false;
     }
     catch {
         // file missing — proceed
     }
-    await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
-    await fs.promises.writeFile(outFile, content, 'utf8');
+    await promises.mkdir(dirname(outFile), { recursive: true });
+    await promises.writeFile(outFile, content, 'utf8');
     return true;
 };
 const walk$1 = async (dir, out = []) => {
-    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    const entries = await promises.readdir(dir, { withFileTypes: true });
     for (const ent of entries) {
-        const p = path.join(dir, ent.name);
+        const p = join(dir, ent.name);
         if (ent.isDirectory()) {
             await walk$1(p, out);
         }
@@ -506,13 +503,13 @@ const walk$1 = async (dir, out = []) => {
     return out;
 };
 const collect = async (root) => {
-    const base = path.join(root, 'app', 'functions');
+    const base = join(root, 'app', 'functions');
     const buckets = { lambda: [], openapi: [], serverless: [] };
-    if (!fs.existsSync(base))
+    if (!existsSync(base))
         return buckets;
     const files = await walk$1(base);
     for (const abs of files) {
-        const name = abs.split(path.sep).pop() ?? '';
+        const name = abs.split(sep).pop() ?? '';
         if (name === 'lambda.ts')
             buckets.lambda.push(abs);
         if (name === 'openapi.ts')
@@ -532,7 +529,7 @@ const collect = async (root) => {
  * dynamic import in the inline server works reliably under tsx.
  */
 const makeImports = (root, outDir, files) => files.map((abs) => {
-    const relFromOut = toPosix$1(path.relative(outDir, abs));
+    const relFromOut = toPosix$1(relative(outDir, abs));
     const noExt = withoutTsExt(relFromOut);
     const spec = noExt.startsWith('.') ? noExt : `./${noExt}`;
     return `import '${spec}';`;
@@ -544,23 +541,23 @@ const buildFile = (imports) => {
 };
 const runRegister = async (root) => {
     const buckets = await collect(root);
-    const outDir = path.join(root, 'app', 'generated');
+    const outDir = join(root, 'app', 'generated');
     const lambdaImports = makeImports(root, outDir, buckets.lambda);
     const openapiImports = makeImports(root, outDir, buckets.openapi);
     const serverlessImports = makeImports(root, outDir, buckets.serverless);
-    const fnsPath = path.join(outDir, 'register.functions.ts');
-    const oaiPath = path.join(outDir, 'register.openapi.ts');
-    const srvPath = path.join(outDir, 'register.serverless.ts');
+    const fnsPath = join(outDir, 'register.functions.ts');
+    const oaiPath = join(outDir, 'register.openapi.ts');
+    const srvPath = join(outDir, 'register.serverless.ts');
     const fns = await formatMaybe(root, fnsPath, buildFile(lambdaImports));
     const oai = await formatMaybe(root, oaiPath, buildFile(openapiImports));
     const srv = await formatMaybe(root, srvPath, buildFile(serverlessImports));
     const wrote = [];
     if (await writeIfChanged(fnsPath, fns))
-        wrote.push(path.posix.normalize(fnsPath));
+        wrote.push(posix.normalize(fnsPath));
     if (await writeIfChanged(oaiPath, oai))
-        wrote.push(path.posix.normalize(oaiPath));
+        wrote.push(posix.normalize(oaiPath));
     if (await writeIfChanged(srvPath, srv))
-        wrote.push(path.posix.normalize(srvPath));
+        wrote.push(posix.normalize(srvPath));
     return { wrote };
 };
 
@@ -592,8 +589,8 @@ const resolveStage = async (root, cliStage, verbose) => {
     // getdotenv.config.json → plugins.smoz.stage
     try {
         const cfgPath = path.resolve(root, 'getdotenv.config.json');
-        if (fs.existsSync(cfgPath)) {
-            const raw = fs.readFileSync(cfgPath, 'utf8');
+        if (existsSync(cfgPath)) {
+            const raw = readFileSync(cfgPath, 'utf8');
             const parsed = JSON.parse(raw);
             const fromCfg = parsed.plugins?.smoz?.stage;
             if (typeof fromCfg === 'string' && fromCfg.trim().length > 0) {
@@ -618,7 +615,7 @@ const seedEnvForStage = async (root, stage, verbose) => {
     // Best effort: import the app config to read declared env keys and concrete values.
     // Preserve existing process.env values; only seed when unset.
     try {
-        const appConfigUrl = node_url.pathToFileURL(path.resolve(root, 'app', 'config', 'app.config.ts')).href;
+        const appConfigUrl = pathToFileURL(path.resolve(root, 'app', 'config', 'app.config.ts')).href;
         // Dynamically import the TS module under tsx
         const mod = (await import(appConfigUrl));
         const app = mod.app;
@@ -692,7 +689,7 @@ const resolveTsxCommand = (root, tsEntry) => {
             shell: false,
         };
     }
-    const probe = node_child_process.spawnSync(process.platform === 'win32' ? 'tsx.cmd' : 'tsx', ['--version'], { shell: true });
+    const probe = spawnSync(process.platform === 'win32' ? 'tsx.cmd' : 'tsx', ['--version'], { shell: true });
     if (typeof probe.status === 'number' && probe.status === 0) {
         return {
             cmd: process.platform === 'win32' ? 'tsx.cmd' : 'tsx',
@@ -714,13 +711,13 @@ const launchInline = async (root, opts) => {
     // Prefer __dirname when available (CJS), otherwise derive from import.meta.url (ESM).
     const here = typeof __dirname === 'string'
         ? __dirname
-        : path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
-    const pkgRoot = packageDirectory.packageDirectorySync({ cwd: here }) ?? process.cwd();
+        : path.dirname(fileURLToPath(import.meta.url));
+    const pkgRoot = packageDirectorySync({ cwd: here }) ?? process.cwd();
     const { entry } = resolveInlineEntry(pkgRoot);
     const makeTsx = () => {
         const { cmd, args, shell } = resolveTsxCommand(root, entry);
         return (async () => {
-            const env = getDotenv.buildSpawnEnv({
+            const env = buildSpawnEnv({
                 ...process.env,
                 // Enable tsconfig paths for "@/..." during TS fallback.
                 TSX_TSCONFIG_PATHS: '1',
@@ -728,7 +725,7 @@ const launchInline = async (root, opts) => {
                 SMOZ_PORT: String(opts.port),
                 SMOZ_VERBOSE: opts.verbose ? '1' : '',
             });
-            return node_child_process.spawn(cmd, args, {
+            return spawn(cmd, args, {
                 cwd: root,
                 stdio: 'inherit',
                 shell,
@@ -894,16 +891,16 @@ const runDev = async (root, opts) => {
 };
 
 const writeIfAbsent = async (outFile, content) => {
-    if (fs.existsSync(outFile))
+    if (existsSync(outFile))
         return { created: false };
-    await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
-    await fs.promises.writeFile(outFile, content, 'utf8');
+    await promises.mkdir(dirname(outFile), { recursive: true });
+    await promises.writeFile(outFile, content, 'utf8');
     return { created: true };
 };
 const walk = async (dir, out = []) => {
-    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    const entries = await promises.readdir(dir, { withFileTypes: true });
     for (const ent of entries) {
-        const p = path.join(dir, ent.name);
+        const p = join(dir, ent.name);
         if (ent.isDirectory()) {
             await walk(p, out);
         }
@@ -915,7 +912,7 @@ const walk = async (dir, out = []) => {
 };
 const readJson = async (file) => {
     try {
-        const data = await fs.promises.readFile(file, 'utf8');
+        const data = await promises.readFile(file, 'utf8');
         return JSON.parse(data);
     }
     catch {
@@ -923,8 +920,8 @@ const readJson = async (file) => {
     }
 };
 const writeJson = async (file, obj) => {
-    await fs.promises.mkdir(path.dirname(file), { recursive: true });
-    await fs.promises.writeFile(file, JSON.stringify(obj, null, 2), 'utf8');
+    await promises.mkdir(dirname(file), { recursive: true });
+    await promises.writeFile(file, JSON.stringify(obj, null, 2), 'utf8');
 };
 
 const askConflict = async (rl, filePath) => {
@@ -950,25 +947,25 @@ const copyDirWithConflicts = async (srcDir, dstRoot, created, skipped, examples,
     const files = await walk(srcDir);
     let sticky;
     for (const abs of files) {
-        const rel = path.relative(srcDir, abs);
+        const rel = relative(srcDir, abs);
         if (opts.exclude && opts.exclude(rel)) {
             // Skip dev-only or excluded files silently.
             continue;
         }
-        const dest = path.resolve(dstRoot, rel);
-        const data = await fs.promises.readFile(abs, 'utf8');
-        if (!fs.existsSync(dest)) {
+        const dest = resolve(dstRoot, rel);
+        const data = await promises.readFile(abs, 'utf8');
+        if (!existsSync(dest)) {
             const { created: c } = await writeIfAbsent(dest, data);
             if (c)
-                created.push(path.posix.normalize(dest));
+                created.push(posix.normalize(dest));
             else
-                skipped.push(path.posix.normalize(dest));
+                skipped.push(posix.normalize(dest));
             continue;
         }
         // Conflict flow
         let decision = opts.conflict === 'ask' ? 'example' : opts.conflict;
         if (opts.conflict === 'ask' && opts.rl && !sticky) {
-            const ans = await askConflict(opts.rl, path.posix.normalize(dest));
+            const ans = await askConflict(opts.rl, posix.normalize(dest));
             if (ans === 'all-overwrite') {
                 sticky = 'overwrite';
             }
@@ -985,32 +982,32 @@ const copyDirWithConflicts = async (srcDir, dstRoot, created, skipped, examples,
         if (sticky)
             decision = sticky;
         if (decision === 'overwrite') {
-            await fs.promises.mkdir(path.dirname(dest), { recursive: true });
-            await fs.promises.writeFile(dest, data, 'utf8');
-            created.push(path.posix.normalize(dest));
+            await promises.mkdir(dirname(dest), { recursive: true });
+            await promises.writeFile(dest, data, 'utf8');
+            created.push(posix.normalize(dest));
         }
         else if (decision === 'example') {
             const ex = `${dest}.example`;
             const { created: c } = await writeIfAbsent(ex, data);
             if (c)
-                examples.push(path.posix.normalize(ex));
+                examples.push(posix.normalize(ex));
             else
-                skipped.push(path.posix.normalize(ex));
+                skipped.push(posix.normalize(ex));
         }
         else {
-            skipped.push(path.posix.normalize(dest));
+            skipped.push(posix.normalize(dest));
         }
     }
 };
 
 const detectPm = (root) => {
-    if (fs.existsSync(path.join(root, 'pnpm-lock.yaml')))
+    if (existsSync(join(root, 'pnpm-lock.yaml')))
         return 'pnpm';
-    if (fs.existsSync(path.join(root, 'yarn.lock')))
+    if (existsSync(join(root, 'yarn.lock')))
         return 'yarn';
-    if (fs.existsSync(path.join(root, 'package-lock.json')))
+    if (existsSync(join(root, 'package-lock.json')))
         return 'npm';
-    if (fs.existsSync(path.join(root, 'bun.lockb')))
+    if (existsSync(join(root, 'bun.lockb')))
         return 'bun';
     const ua = process.env.npm_config_user_agent ?? '';
     if (ua.includes('pnpm'))
@@ -1029,7 +1026,7 @@ const runInstall = (root, pm) => {
     const known = pm === 'pnpm' || pm === 'yarn' || pm === 'bun' || pm === 'npm';
     if (!known)
         return 'unknown-pm';
-    const res = node_child_process.spawnSync(pm, ['install'], {
+    const res = spawnSync(pm, ['install'], {
         stdio: 'inherit',
         cwd: root,
         shell: true,
@@ -1094,8 +1091,8 @@ const mergeAdditive = (target, source) => {
  */
 const ensureToolkitDependency = async (targetPkg, templatesBase) => {
     try {
-        const toolkitRoot = path.dirname(templatesBase);
-        const toolkitPkg = await readJson(path.join(toolkitRoot, 'package.json'));
+        const toolkitRoot = dirname(templatesBase);
+        const toolkitPkg = await readJson(join(toolkitRoot, 'package.json'));
         const verRaw = toolkitPkg?.version?.trim();
         const depVersion = verRaw ? `^${verRaw}` : '^0.0.0';
         const deps = targetPkg.dependencies ?? {};
@@ -1118,27 +1115,27 @@ const ensureToolkitDependency = async (targetPkg, templatesBase) => {
  * a consuming app and from this repository.
 + */
 const resolveTemplatesBase = () => {
-    const here = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
-    const pkgRoot = packageDirectory.packageDirectorySync({ cwd: here }) ?? process.cwd();
-    return path.resolve(pkgRoot, 'templates');
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkgRoot = packageDirectorySync({ cwd: here }) ?? process.cwd();
+    return resolve(pkgRoot, 'templates');
 };
 const toPosix = (p) => 
 // local helper for path presentation (not used for FS operations)
 p.replace(/\\/g, '/');
 
 const seedRegisterPlaceholders = async (root) => {
-    const genDir = path.join(root, 'app', 'generated');
+    const genDir = join(root, 'app', 'generated');
     const seeds = [
         {
-            path: path.join(genDir, 'register.functions.ts'),
+            path: join(genDir, 'register.functions.ts'),
             content: '/* AUTO-GENERATED placeholder; will be rewritten by `smoz register` */\nexport {};\n',
         },
         {
-            path: path.join(genDir, 'register.openapi.ts'),
+            path: join(genDir, 'register.openapi.ts'),
             content: '/* AUTO-GENERATED placeholder; will be rewritten by `smoz register` */\nexport {};\n',
         },
         {
-            path: path.join(genDir, 'register.serverless.ts'),
+            path: join(genDir, 'register.serverless.ts'),
             content: '/* AUTO-GENERATED placeholder; will be rewritten by `smoz register` */\nexport {};\n',
         },
     ];
@@ -1146,12 +1143,12 @@ const seedRegisterPlaceholders = async (root) => {
     const skipped = [];
     for (const s of seeds) {
         const { created: c } = await writeIfAbsent(s.path, s.content);
-        (c ? created : skipped).push(path.posix.normalize(s.path));
+        (c ? created : skipped).push(posix.normalize(s.path));
     }
     return { created, skipped };
 };
 
-const toPosixSep = (p) => p.split(path.sep).join('/');
+const toPosixSep = (p) => p.split(sep).join('/');
 // Exclude dev-only type stubs (not meant for downstream apps).
 const excludeDev = (rel) => {
     const posixRel = rel.replace(/\\/g, '/');
@@ -1178,19 +1175,19 @@ const runInit = async (root, template = 'default', opts) => {
     const optAll = opts ?? {};
     const templatesBase = resolveTemplatesBase();
     // Resolve template source: named template or filesystem path
-    const templateIsPath = fs.existsSync(template) && (await fs.promises.stat(template)).isDirectory();
+    const templateIsPath = existsSync(template) && (await promises.stat(template)).isDirectory();
     const srcBase = templateIsPath
-        ? path.resolve(template)
-        : path.resolve(templatesBase, template);
-    const projectBase = path.resolve(templatesBase, 'project');
-    if (!fs.existsSync(srcBase)) {
+        ? resolve(template)
+        : resolve(templatesBase, template);
+    const projectBase = resolve(templatesBase, 'project');
+    if (!existsSync(srcBase)) {
         throw new Error(`Template "${template}" not found (path or name). Tried: ${toPosix(srcBase)}.`);
     }
     // 1) Copy shared project boilerplate
-    if (fs.existsSync(projectBase)) {
+    if (existsSync(projectBase)) {
         const rl = optAll.yes === true
             ? undefined
-            : promises.createInterface({ input: node_process.stdin, output: node_process.stdout, terminal: true });
+            : createInterface({ input: stdin, output: stdout, terminal: true });
         let policy;
         const c = optAll.conflict;
         if (c === 'overwrite' || c === 'example' || c === 'skip' || c === 'ask')
@@ -1210,7 +1207,7 @@ const runInit = async (root, template = 'default', opts) => {
     {
         const rl = optAll.yes === true
             ? undefined
-            : promises.createInterface({ input: node_process.stdin, output: node_process.stdout, terminal: true });
+            : createInterface({ input: stdin, output: stdout, terminal: true });
         let policy;
         const c = optAll.conflict;
         if (c === 'overwrite' || c === 'example' || c === 'skip' || c === 'ask')
@@ -1228,21 +1225,21 @@ const runInit = async (root, template = 'default', opts) => {
     }
     // 2.5) Convert template 'gitignore' into a real '.gitignore'
     try {
-        const giSrc = path.join(root, 'gitignore');
-        const giDot = path.join(root, '.gitignore');
-        if (fs.existsSync(giSrc)) {
-            if (!fs.existsSync(giDot)) {
-                await fs.promises.rename(giSrc, giDot);
-                created.push(path.posix.normalize(giDot));
+        const giSrc = join(root, 'gitignore');
+        const giDot = join(root, '.gitignore');
+        if (existsSync(giSrc)) {
+            if (!existsSync(giDot)) {
+                await promises.rename(giSrc, giDot);
+                created.push(posix.normalize(giDot));
             }
             else {
-                const example = path.join(root, 'gitignore.example');
-                if (!fs.existsSync(example)) {
-                    const data = await fs.promises.readFile(giSrc, 'utf8');
-                    await fs.promises.writeFile(example, data, 'utf8');
-                    examples.push(path.posix.normalize(example));
+                const example = join(root, 'gitignore.example');
+                if (!existsSync(example)) {
+                    const data = await promises.readFile(giSrc, 'utf8');
+                    await promises.writeFile(example, data, 'utf8');
+                    examples.push(posix.normalize(example));
                 }
-                await fs.promises.rm(giSrc, { force: true });
+                await promises.rm(giSrc, { force: true });
             }
         }
     }
@@ -1251,22 +1248,22 @@ const runInit = async (root, template = 'default', opts) => {
     }
     // 2.6) Convert 'tsconfig.downstream.json' into 'tsconfig.json'
     try {
-        const ds = path.join(root, 'tsconfig.downstream.json');
-        const dst = path.join(root, 'tsconfig.json');
-        if (fs.existsSync(ds)) {
-            if (!fs.existsSync(dst)) {
-                await fs.promises.rename(ds, dst);
-                created.push(path.posix.normalize(dst));
+        const ds = join(root, 'tsconfig.downstream.json');
+        const dst = join(root, 'tsconfig.json');
+        if (existsSync(ds)) {
+            if (!existsSync(dst)) {
+                await promises.rename(ds, dst);
+                created.push(posix.normalize(dst));
             }
             else {
                 // If a tsconfig already exists, write an example and remove the source
-                const example = path.join(root, 'tsconfig.json.example');
-                if (!fs.existsSync(example)) {
-                    const data = await fs.promises.readFile(ds, 'utf8');
-                    await fs.promises.writeFile(example, data, 'utf8');
-                    examples.push(path.posix.normalize(example));
+                const example = join(root, 'tsconfig.json.example');
+                if (!existsSync(example)) {
+                    const data = await promises.readFile(ds, 'utf8');
+                    await promises.writeFile(example, data, 'utf8');
+                    examples.push(posix.normalize(example));
                 }
-                await fs.promises.rm(ds, { force: true });
+                await promises.rm(ds, { force: true });
             }
         }
     }
@@ -1280,7 +1277,7 @@ const runInit = async (root, template = 'default', opts) => {
         skipped.push(...res.skipped);
     }
     // 3) package.json presence (create when missing)
-    const pkgPath = path.join(root, 'package.json');
+    const pkgPath = join(root, 'package.json');
     let pkg = await readJson(pkgPath);
     if (!pkg) {
         const name = toPosixSep(root).split('/').pop() ?? 'smoz-app';
@@ -1293,13 +1290,13 @@ const runInit = async (root, template = 'default', opts) => {
         };
         if (!optAll.dryRun)
             await writeJson(pkgPath, pkg);
-        created.push(path.posix.normalize(pkgPath));
+        created.push(posix.normalize(pkgPath));
     }
     // 4) Merge manifest additively (prefer template's embedded package.json)
-    const templatePkgPath = path.resolve(srcBase, 'package.json');
-    const manifest = fs.existsSync(templatePkgPath)
+    const templatePkgPath = resolve(srcBase, 'package.json');
+    const manifest = existsSync(templatePkgPath)
         ? await readJson(templatePkgPath)
-        : await readJson(path.resolve(templatesBase, '.manifests', `package.${template}.json`));
+        : await readJson(resolve(templatesBase, '.manifests', `package.${template}.json`));
     let pkgChanged = false;
     if (manifest) {
         const added = mergeAdditive(pkg, manifest);
@@ -1340,7 +1337,7 @@ const runInit = async (root, template = 'default', opts) => {
  * Registers init/add/register/openapi/dev on a GetDotenvCli instance and
  * delegates to existing implementations. No business logic here.
  */
-const repoRoot = () => packageDirectory.packageDirectorySync() ?? process.cwd();
+const repoRoot = () => packageDirectorySync() ?? process.cwd();
 const setupSmozCommands = (cli) => {
     // init
     cli
@@ -1443,7 +1440,7 @@ const setupSmozCommands = (cli) => {
         });
     });
 };
-const smozPlugin = () => cliHost.definePlugin({
+const smozPlugin = () => definePlugin({
     ns: 'smoz',
     setup: setupSmozCommands,
 });
@@ -1456,7 +1453,7 @@ const smozPlugin = () => cliHost.definePlugin({
  * - Install included plugins (cmd/batch/aws) and the SMOZ command plugin
  *   (init/add/register/openapi/dev).
  */
-const main = cli.createCli({
+const main = createCli({
     alias: 'smoz',
     compose: (cli) => {
         const setupResult = smozPlugin().setup(cli);
@@ -1464,12 +1461,12 @@ const main = cli.createCli({
             throw new Error('smozPlugin root setup must remain synchronous.');
         }
         return cli
-            .use(plugins.awsPlugin())
-            .use(plugins.cmdPlugin({
+            .use(awsPlugin())
+            .use(cmdPlugin({
             asDefault: true,
             optionAlias: '-c, --cmd <command...>',
         }))
-            .use(plugins.batchPlugin());
+            .use(batchPlugin());
     },
 });
 void main();

package/package.json

@@ -7,7 +7,7 @@
     "hideCredit": true
   },
   "bin": {
-    "smoz": "dist/cli/index.cjs"
+    "smoz": "dist/cli/index.mjs"
   },
   "bugs": {
     "url": "https://github.com/karmaniverous/smoz/issues"
@@ -183,7 +183,7 @@
     "templates:lint": "eslint --fix -c templates/default/eslint.config.ts \"templates/default/**/*.{ts,tsx,js,jsx}\" \"templates/default/eslint.config.ts\""
   },
   "type": "module",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "volta": {
     "node": "22.19.0"
   }