@anaemia/cli 0.1.8 → 0.3.0

package/src/commands/create.ts

@@ -0,0 +1,229 @@
+import type { CAC } from "cac";
+import logger from "../utils/logger.js";
+import path from "path";
+import fs from "fs";
+import pc from "picocolors";
+import { generateSharedComponent, scaffoldFeature, scaffoldHook, scaffoldPage } from "../scaffold.js";
+import { execSync } from "node:child_process";
+import prompts from "prompts";
+import { transform } from "sucrase";
+
+export function register(cli: CAC) {
+  cli
+  .command("create [target]", "initialize an application or generate domain features (e.g., feature:name)")
+  .alias("init")
+  .action(async (target) => {
+    const appRoot = process.cwd();
+
+    if (target && target.includes(":")) {
+      const [type, name] = target.split(":");
+
+      if (!name) {
+        logger.error(`missing name modifier. Use layout template like: ${pc.cyan(`create ${type}:your-name`)}`);
+        process.exit(1);
+      }
+
+      if (!fs.existsSync(path.join(appRoot, "package.json"))) {
+        logger.error("no package.json detected. code generation commands must run inside an Anaemia project root.");
+        process.exit(1);
+      }
+
+      const normalizedName = name.trim();
+
+      if (type === "feature") {
+        scaffoldFeature(normalizedName, appRoot);
+        return;
+      }
+
+      if (type === "component") {
+        generateSharedComponent(appRoot, normalizedName, { logger, pc });
+        return;
+      }
+
+      if (type === "page") {
+        scaffoldPage(normalizedName, appRoot);
+        return;
+      }
+
+      if (type === "hook") {
+        scaffoldHook(normalizedName, appRoot);
+        return;
+      }
+
+      logger.error(`unknown layout generator type "${type}". Supported variants: "feature:", "component:", "page:", "hook:"`);
+      process.exit(1);
+    }
+
+    logger.compiler("launching Anaemia project initialization wizard...");
+
+    const response = await prompts([
+      {
+        type: target ? null : "text",
+        name: "projectName",
+        message: "Project name:",
+        initial: "anaemia-app",
+      },
+      {
+        type: "select",
+        name: "variant",
+        message: "Select a variant:",
+        choices: [
+          { title: pc.blue("TypeScript (Recommended)"), value: "ts" },
+          { title: pc.yellow("JavaScript"), value: "js" },
+        ],
+        initial: 0,
+      },
+    ]);
+
+    if (!response.variant && response.variant !== 0) {
+      logger.warn("project creation aborted.");
+      process.exit(0);
+    }
+
+    const targetDir = target || response.projectName;
+    const targetPath = path.resolve(appRoot, targetDir);
+
+    if (fs.existsSync(targetPath)) {
+      const files = fs.readdirSync(targetPath);
+      if (files.length > 0) {
+        const { overwrite } = await prompts({
+          type: "confirm",
+          name: "overwrite",
+          message: `target directory "${targetDir}" is not empty. remove existing files and continue?`,
+          initial: false,
+        });
+
+        if (!overwrite) {
+          logger.error("aborted to protect existing project directory.");
+          process.exit(1);
+        }
+
+        logger.warn(`purging existing files inside ${targetDir}...`);
+        fs.rmSync(targetPath, { recursive: true, force: true });
+        fs.mkdirSync(targetPath, { recursive: true });
+      }
+    } else {
+      fs.mkdirSync(targetPath, { recursive: true });
+    }
+
+    let templatePath = path.resolve(__dirname, "../templates/template-base");
+    if (!fs.existsSync(templatePath)) {
+      templatePath = path.resolve(__dirname, "../templates/base-app");
+    }
+
+    if (fs.existsSync(templatePath)) {
+      logger.info("unpacking localized scaffolding architecture layout structures...");
+      fs.cpSync(templatePath, targetPath, {
+        recursive: true,
+        filter: (src) => !["node_modules", "dist", ".anaemia", ".rspack"].includes(path.basename(src)),
+      });
+    } else {
+      logger.warn("local templates missing. fetching remote registry packages over the network...");
+      const userAgent = process.env.npm_config_user_agent || "";
+      let packageManager = "npm";
+      if (userAgent.includes("pnpm")) packageManager = "pnpm";
+      else if (userAgent.includes("yarn")) packageManager = "yarn";
+
+      try {
+        if (packageManager === "pnpm") {
+          execSync(`pnpm dlx degit colourlabs/anaemia/templates/base-app "${targetPath}"`, { stdio: "ignore" });
+        } else {
+          execSync(`npx degit colourlabs/anaemia/templates/base-app "${targetPath}"`, { stdio: "ignore" });
+        }
+      } catch (err) {
+        logger.error("could not source template workspace assets locally or from network registry nodes. " + err);
+        process.exit(1);
+      }
+    }
+
+    const removeGitKeepFiles = (dir: string) => {
+      const files = fs.readdirSync(dir);
+      for (const file of files) {
+        const fullPath = path.join(dir, file);
+        if (fs.statSync(fullPath).isDirectory()) {
+          removeGitKeepFiles(fullPath);
+        } else if (file === ".gitkeep") {
+          fs.unlinkSync(fullPath);
+        }
+      }
+    };
+    removeGitKeepFiles(targetPath);
+
+    if (response.variant === "js") {
+      logger.info("converting workspace assets to vanilla JavaScript...");
+
+      const convertTypeScriptToJs = (dir: string) => {
+        const files = fs.readdirSync(dir);
+
+        for (const file of files) {
+          const fullPath = path.join(dir, file);
+          const stat = fs.statSync(fullPath);
+
+          if (stat.isDirectory()) {
+            convertTypeScriptToJs(fullPath);
+          } else if (file.endsWith(".ts") || file.endsWith(".tsx")) {
+            const isTsx = file.endsWith(".tsx");
+            const code = fs.readFileSync(fullPath, "utf8");
+
+            try {
+              const compiled = transform(code, {
+                transforms: isTsx ? ["typescript", "jsx"] : ["typescript"],
+                jsxRuntime: "preserve",
+                production: true,
+              });
+
+              const newExt = isTsx ? ".jsx" : ".js";
+              const newPath = fullPath.replace(/\.tsx?$/, newExt);
+
+              fs.writeFileSync(newPath, compiled.code, "utf8");
+              fs.unlinkSync(fullPath);
+            } catch {
+              logger.warn(`failed to strip types from ${file}, skipping...`);
+            }
+          }
+        }
+      };
+
+      convertTypeScriptToJs(targetPath);
+
+      const tsconfigPath = path.join(targetPath, "tsconfig.json");
+      if (fs.existsSync(tsconfigPath)) {
+        fs.unlinkSync(tsconfigPath);
+      }
+    }
+
+    const pkgJsonPath = path.join(targetPath, "package.json");
+    if (fs.existsSync(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+        pkg.name = path.basename(targetPath);
+
+        if (response.variant === "js") {
+          if (pkg.devDependencies) {
+            delete pkg.devDependencies["typescript"];
+            delete pkg.devDependencies["@types/node"];
+            delete pkg.devDependencies["@typescript-eslint/eslint-plugin"];
+            delete pkg.devDependencies["@typescript-eslint/parser"];
+          }
+          if (pkg.scripts && pkg.scripts.typecheck) {
+            delete pkg.scripts.typecheck;
+          }
+        }
+
+        fs.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2), "utf8");
+      } catch (err) {
+        logger.error("failed rewriting package.json manifest structures:", err);
+      }
+    }
+
+    logger.success(`\n🎉 project successfully scaffolded into ${pc.magenta(targetDir)}!`);
+    console.log(pc.dim("\nfollow these steps to begin execution:\n"));
+
+    if (targetDir !== ".") {
+      console.log(`  cd ${pc.cyan(targetDir)}`);
+    }
+    console.log(`  ${pc.cyan("pnpm install")}    ${pc.dim("# or npm i / yarn install")}`);
+    console.log(`  ${pc.cyan("pnpm dev")}        ${pc.dim("# launches hot reload server")}\n`);
+  });
+
+};

package/src/commands/dev.ts

@@ -0,0 +1,125 @@
+import type { CAC } from "cac";
+import { rspack } from "@rspack/core";
+import { RspackDevServer } from "@rspack/dev-server";
+import { getRspackConfig } from "@anaemia/bundler";
+import spawn from "cross-spawn";
+import path from "node:path";
+import http from "node:http";
+import { WebSocketServer } from "ws";
+import { WebSocket as NodeWS } from "ws";
+import { loadUserConfig } from "../utils/config.js";
+import logger from "../utils/logger.js";
+import { ChildProcess } from "node:child_process";
+
+export function register(cli: CAC) {
+  cli.command("dev", "launch local development environment").action(async () => {
+    process.env.NODE_ENV = "development";
+    const appRoot = process.cwd();
+
+    const userConfig = await loadUserConfig(appRoot);
+    const targetPort = userConfig.port || 3000;
+
+    const [clientConfig, serverConfig] = await getRspackConfig(appRoot, userConfig);
+
+    const clientCompiler = rspack(clientConfig);
+    const devServer = new RspackDevServer(clientConfig.devServer || {}, clientCompiler);
+
+    const bridgeServer = http.createServer();
+    const wss = new WebSocketServer({ server: bridgeServer });
+
+    wss.on("connection", (clientWs) => {
+      const rspackSocket = new NodeWS(`ws://localhost:${targetPort + 1}/ws`);
+
+      rspackSocket.on("message", (data) => {
+        const flattened = Array.isArray(data) ? Buffer.concat(data) : data;
+        if (Buffer.isBuffer(flattened)) clientWs.send(flattened.toString("utf-8"));
+        else clientWs.send(String(flattened));
+      });
+
+      rspackSocket.on("error", (err) => {
+        console.warn("[anaemia hmr] rspack socket error:", err.message);
+      });
+
+      clientWs.on("message", (data) => {
+        if (rspackSocket.readyState === NodeWS.OPEN) rspackSocket.send(data);
+      });
+
+      clientWs.on("close", () => {
+        if (rspackSocket.readyState === NodeWS.OPEN) rspackSocket.close();
+      });
+    });
+
+    let serverProcess: ChildProcess | null = null;
+
+    const startServer = () => {
+      if (serverProcess) {
+        serverProcess.kill("SIGTERM");
+        serverProcess = null;
+      }
+
+      setTimeout(() => {
+        serverProcess = spawn(
+          "node",
+          ["--enable-source-maps", path.resolve(appRoot, "./dist/server/index.js")],
+          {
+            stdio: "inherit",
+            env: {
+              ...process.env,
+              NODE_ENV: "development",
+              PORT: String(targetPort),
+              RSPACK_DEV_PORT: String(targetPort + 1),
+            },
+          }
+        );
+      }, 200);
+    };
+
+    const cleanup = async () => {
+      if (serverProcess) {
+        serverProcess.kill("SIGTERM");
+        serverProcess = null;
+      }
+      bridgeServer.close();
+      serverCompiler?.close(() => {});
+      if (devServer) {
+        await devServer.stop();
+      }
+      process.exit(0);
+    };
+
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+
+    logger.compiler("warming up and analyzing assets...");
+
+    try {
+      await devServer.start();
+      logger.success(`hot reload asset infrastructure running on port ${targetPort + 1}`);
+    } catch (err) {
+      logger.error("failed to start client asset dev server:", err);
+      process.exit(1);
+    }
+
+    bridgeServer.listen(targetPort + 2, () => {
+      logger.info(`HMR bridge running on port ${targetPort + 2}`);
+    });
+
+    const serverCompiler = rspack(serverConfig);
+
+    serverCompiler.watch({}, (err, stats) => {
+      if (err) {
+        logger.error("server compilation critical failure:", err);
+        return;
+      }
+
+      if (stats?.hasErrors()) {
+        console.error(stats.toString({ colors: true, all: false, errors: true, warnings: true }));
+        logger.error("server compilation encountered build script errors.");
+        return;
+      }
+
+      logger.info(`server bundles updated. booting runtime on http://localhost:${targetPort}`);
+      startServer();
+    });
+  });
+}

package/src/commands/routes.ts

@@ -0,0 +1,34 @@
+import type { CAC } from "cac";
+import logger from "../utils/logger.js";
+import { scanRoutes } from "@anaemia/bundler";
+import pc from "picocolors";
+
+export function register(cli: CAC) {
+  cli.command("routes", "print the scanned route manifest").action(async () => {
+    const appRoot = process.cwd();
+    const routes = await scanRoutes(appRoot);
+
+    logger.info("scanned route architecture:\n");
+
+    routes.forEach((r, i) => {
+      const isLast = i === routes.length - 1;
+      const branch = isLast ? "└─" : "├─";
+      const indent = isLast ? "   " : "│  ";
+
+      const typeLabel = r.type === "catch-all" ? pc.red(`[${r.type}]`) : r.type === "layout" ? pc.yellow(`[${r.type}]`) : pc.green(`[${r.type}]`);
+      console.log(`${branch} ${pc.cyan(r.urlPattern)} ${typeLabel}`);
+
+      const lines: string[] = [];
+      if (r.params.length) lines.push(`params: ${pc.magenta(r.params.join(", "))}`);
+      if (r.chunkName) lines.push(`chunk:  ${pc.dim(r.chunkName)}`);
+      if (r.layouts.length) lines.push(`layouts: ${pc.dim(String(r.layouts.length))}`);
+
+      lines.forEach((line, li) => {
+        const isLastLine = li === lines.length - 1;
+        console.log(`${indent}${isLastLine ? "└─" : "├─"} ${line}`);
+      });
+
+      if (!isLast) console.log("│");
+    });
+  });
+}

package/src/commands/start.ts

@@ -0,0 +1,17 @@
+import type { CAC } from "cac";
+import { loadUserConfig } from "../utils/config.js";
+import spawn from "cross-spawn";
+import path from "path";
+
+export function register(cli: CAC) {
+  cli.command("start", "serve the production build").action(async () => {
+    const appRoot = process.cwd();
+    const userConfig = await loadUserConfig(appRoot);
+    const targetPort = userConfig.port || 3000;
+
+    spawn("node", [path.resolve(appRoot, "./dist/server/index.js")], {
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: "production", PORT: String(targetPort) },
+    });
+  });
+};

package/src/commands/typecheck.ts

@@ -0,0 +1,10 @@
+import type { CAC } from "cac";
+import spawn from "cross-spawn";
+
+export function register(cli: CAC) {
+  cli.command("typecheck", "run TypeScript type checking without emitting").action(async () => {
+    const appRoot = process.cwd();
+    const result = spawn.sync("tsc", ["--noEmit"], { stdio: "inherit", cwd: appRoot });
+    if (result.status !== 0) process.exit(result.status ?? 1);
+  });
+};