blumenjs 0.1.0

package/dist/cli/blumen.js

@@ -0,0 +1,697 @@
+#!/usr/bin/env node
+// cli/commands/dev.ts
+import { spawn, execSync } from "child_process";
+
+// cli/utils.ts
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var log = {
+  info: (msg) => console.log(`  ${c.magenta}\u25CF${c.reset}  ${msg}`),
+  success: (msg) => console.log(`  ${c.green}\u2713${c.reset}  ${msg}`),
+  error: (msg) => console.error(`  ${c.red}\u2717${c.reset}  ${msg}`),
+  warn: (msg) => console.log(`  ${c.yellow}\u26A0${c.reset}  ${msg}`),
+  step: (msg) => console.log(`  ${c.dim}\u2192${c.reset}  ${msg}`),
+  blank: () => console.log("")
+};
+function banner() {
+  console.log("");
+  console.log(
+    `  ${c.magenta}${c.bold}\u{1F338} Blumen${c.reset} ${c.dim}v0.1.0${c.reset}`
+  );
+  console.log(
+    `  ${c.dim}The React framework powered by Go${c.reset}`
+  );
+  console.log("");
+}
+function divider() {
+  console.log(`  ${c.dim}${"\u2500".repeat(48)}${c.reset}`);
+}
+async function select(question, options) {
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    console.log(`
+  ${c.bold}${question}${c.reset}`);
+    options.forEach((opt, i) => {
+      console.log(`    ${c.cyan}${i + 1}${c.reset}) ${opt}`);
+    });
+    rl.question(`
+  ${c.dim}Enter choice [1-${options.length}]:${c.reset} `, (answer) => {
+      rl.close();
+      const idx = parseInt(answer, 10) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve2(options[idx]);
+      } else {
+        resolve2(options[0]);
+      }
+    });
+  });
+}
+
+// cli/commands/dev.ts
+async function dev() {
+  banner();
+  log.step("Generating routes...");
+  try {
+    execSync("npx tsx scripts/generate-routes.ts", {
+      stdio: "pipe",
+      cwd: process.cwd()
+    });
+    log.success("Routes generated");
+  } catch {
+    log.error("Route generation failed");
+    process.exit(1);
+  }
+  divider();
+  log.info("Starting development servers...");
+  log.blank();
+  const services = [
+    {
+      name: "webpack",
+      label: "hmr",
+      color: c.magenta,
+      cmd: "npx",
+      args: ["webpack", "serve", "--mode", "development"],
+      readyPattern: /compiled successfully/
+    },
+    {
+      name: "node-ssr",
+      label: "ssr",
+      color: c.cyan,
+      cmd: "npx",
+      args: ["tsx", "watch", "node-ssr/server.ts"],
+      env: { NODE_ENV: "development" },
+      readyPattern: /SSR server running/
+    },
+    {
+      name: "go-server",
+      label: " go",
+      color: c.green,
+      cmd: "go",
+      args: ["run", "go-server/main.go"],
+      readyPattern: /Go server starting/
+    }
+  ];
+  const children = [];
+  const ready = /* @__PURE__ */ new Set();
+  for (const svc of services) {
+    const child = spawn(svc.cmd, svc.args, {
+      cwd: process.cwd(),
+      env: { ...process.env, ...svc.env || {} },
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: false
+    });
+    const prefix = `  ${svc.color}\u2502${c.reset} ${svc.color}${svc.label}${c.reset}  `;
+    const handleOutput = (data) => {
+      const lines = data.toString().split("\n");
+      for (const line of lines) {
+        const trimmed = line.replace(/\r$/, "");
+        if (!trimmed)
+          continue;
+        console.log(`${prefix}${trimmed}`);
+        if (svc.readyPattern && svc.readyPattern.test(trimmed) && !ready.has(svc.name)) {
+          ready.add(svc.name);
+          if (ready.size === services.length) {
+            printReadyBanner();
+          }
+        }
+      }
+    };
+    child.stdout?.on("data", handleOutput);
+    child.stderr?.on("data", handleOutput);
+    child.on("exit", (code) => {
+      if (code !== null && code !== 0) {
+        log.warn(`${svc.name} exited with code ${code}`);
+      }
+    });
+    children.push(child);
+  }
+  function printReadyBanner() {
+    log.blank();
+    divider();
+    log.blank();
+    log.success(`${c.bold}Ready!${c.reset} All services are running.`);
+    log.blank();
+    console.log(
+      `  ${c.dim}\u279C${c.reset}  ${c.bold}App${c.reset}:     ${c.cyan}http://localhost:3000${c.reset}`
+    );
+    console.log(
+      `  ${c.dim}\u279C${c.reset}  ${c.bold}SSR${c.reset}:     ${c.dim}http://localhost:4000${c.reset}`
+    );
+    console.log(
+      `  ${c.dim}\u279C${c.reset}  ${c.bold}HMR${c.reset}:     ${c.dim}http://localhost:3100${c.reset}`
+    );
+    log.blank();
+    console.log(
+      `  ${c.dim}Press ${c.bold}Ctrl+C${c.reset}${c.dim} to stop all services.${c.reset}`
+    );
+    log.blank();
+    divider();
+  }
+  const shutdown = () => {
+    log.blank();
+    log.info("Shutting down...");
+    for (const child of children) {
+      if (!child.killed)
+        child.kill("SIGTERM");
+    }
+    setTimeout(() => {
+      for (const child of children) {
+        if (!child.killed)
+          child.kill("SIGKILL");
+      }
+      log.success("Stopped.");
+      process.exit(0);
+    }, 3e3);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+
+// cli/commands/build.ts
+import { execSync as execSync2 } from "child_process";
+async function build() {
+  banner();
+  log.info("Creating production build...");
+  log.blank();
+  const steps = [
+    {
+      label: "Generating routes",
+      cmd: "npx tsx scripts/generate-routes.ts"
+    },
+    {
+      label: "Building client bundle",
+      cmd: "npx webpack --mode production"
+    },
+    {
+      label: "Building SSR server",
+      cmd: "npx esbuild node-ssr/server.ts --bundle --platform=node --format=esm --outfile=dist/ssr-server.js --external:react --external:react-dom"
+    }
+  ];
+  const startTime = Date.now();
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    log.step(`[${i + 1}/${steps.length}] ${step.label}...`);
+    try {
+      execSync2(step.cmd, { stdio: "inherit", cwd: process.cwd() });
+      log.success(step.label);
+    } catch {
+      log.error(`Failed: ${step.label}`);
+      process.exit(1);
+    }
+  }
+  const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+  log.blank();
+  divider();
+  log.blank();
+  log.success(
+    `${c.bold}Build complete${c.reset} in ${c.cyan}${elapsed}s${c.reset}`
+  );
+  log.info(
+    `Run ${c.bold}blumen start${c.reset} to start the production server.`
+  );
+  log.blank();
+}
+
+// cli/commands/start.ts
+import { spawn as spawn2 } from "child_process";
+import * as fs from "fs";
+async function start() {
+  banner();
+  if (!fs.existsSync("dist/ssr-server.js")) {
+    log.error("Production build not found.");
+    log.info(
+      `Run ${c.bold}blumen build${c.reset} first to create a production build.`
+    );
+    process.exit(1);
+  }
+  log.info("Starting production server...");
+  log.blank();
+  const services = [
+    {
+      name: "ssr",
+      label: "ssr",
+      color: c.cyan,
+      cmd: "node",
+      args: ["dist/ssr-server.js"],
+      readyPattern: /SSR server running|listening/i
+    },
+    {
+      name: "go",
+      label: " go",
+      color: c.green,
+      cmd: "go",
+      args: ["run", "go-server/main.go"],
+      readyPattern: /Go server starting/
+    }
+  ];
+  const children = [];
+  const ready = /* @__PURE__ */ new Set();
+  for (const svc of services) {
+    const child = spawn2(svc.cmd, svc.args, {
+      cwd: process.cwd(),
+      env: { ...process.env, NODE_ENV: "production" },
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    const prefix = `  ${svc.color}\u2502${c.reset} ${svc.color}${svc.label}${c.reset}  `;
+    const handleOutput = (data) => {
+      for (const line of data.toString().split("\n")) {
+        const trimmed = line.replace(/\r$/, "");
+        if (!trimmed)
+          continue;
+        console.log(`${prefix}${trimmed}`);
+        if (svc.readyPattern && svc.readyPattern.test(trimmed) && !ready.has(svc.name)) {
+          ready.add(svc.name);
+          if (ready.size === services.length) {
+            log.blank();
+            divider();
+            log.blank();
+            log.success(
+              `${c.bold}Production server running.${c.reset}`
+            );
+            console.log(
+              `  ${c.dim}\u279C${c.reset}  ${c.cyan}http://localhost:3000${c.reset}`
+            );
+            log.blank();
+          }
+        }
+      }
+    };
+    child.stdout?.on("data", handleOutput);
+    child.stderr?.on("data", handleOutput);
+    children.push(child);
+  }
+  const shutdown = () => {
+    log.blank();
+    log.info("Shutting down...");
+    for (const child of children) {
+      if (!child.killed)
+        child.kill("SIGTERM");
+    }
+    setTimeout(() => {
+      for (const child of children) {
+        if (!child.killed)
+          child.kill("SIGKILL");
+      }
+      process.exit(0);
+    }, 3e3);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+
+// cli/commands/create.ts
+import * as fs2 from "fs";
+import * as path from "path";
+import { execSync as execSync3 } from "child_process";
+function getFrameworkRoot() {
+  const cliEntry = process.argv[1];
+  const cliDir = path.dirname(cliEntry);
+  return path.resolve(cliDir, "..");
+}
+function readProjectFile(relativePath) {
+  const root = getFrameworkRoot();
+  const bundledPath = path.join(root, "templates", relativePath);
+  if (fs2.existsSync(bundledPath)) {
+    return fs2.readFileSync(bundledPath, "utf-8");
+  }
+  const sourcePath = path.join(root, relativePath);
+  if (fs2.existsSync(sourcePath)) {
+    return fs2.readFileSync(sourcePath, "utf-8");
+  }
+  throw new Error(`Template file not found: ${relativePath}`);
+}
+function pkgJson(name) {
+  return JSON.stringify(
+    {
+      name,
+      version: "0.1.0",
+      description: `${name} \u2014 A Blumen app`,
+      type: "module",
+      scripts: {
+        routes: "tsx scripts/generate-routes.ts",
+        dev: 'npm run routes && concurrently "npm run dev:client" "npm run dev:ssr" "npm run dev:go"',
+        "dev:client": "webpack serve --mode development",
+        "dev:ssr": "NODE_ENV=development tsx watch node-ssr/server.ts",
+        "dev:go": "go run go-server/main.go",
+        build: "npm run routes && npm run build:client && npm run build:ssr",
+        "build:client": "webpack --mode production",
+        "build:ssr": "esbuild node-ssr/server.ts --bundle --platform=node --format=esm --outfile=dist/ssr-server.js --external:react --external:react-dom",
+        start: "node dist/ssr-server.js",
+        clean: "rm -rf dist static/js/bundle.js"
+      },
+      dependencies: {
+        "lucide-react": "^1.14.0",
+        react: "^18.2.0",
+        "react-dom": "^18.2.0"
+      },
+      devDependencies: {
+        "@babel/core": "^7.24.0",
+        "@babel/preset-env": "^7.24.0",
+        "@babel/preset-react": "^7.24.0",
+        "@babel/preset-typescript": "^7.24.0",
+        "@pmmmwh/react-refresh-webpack-plugin": "^0.5.15",
+        "@types/node": "^20.10.0",
+        "@types/react": "^18.2.0",
+        "@types/react-dom": "^18.2.0",
+        "babel-loader": "^9.2.1",
+        concurrently: "^8.2.2",
+        esbuild: "^0.19.0",
+        "react-refresh": "^0.14.2",
+        "ts-loader": "^9.5.1",
+        tsx: "^4.6.0",
+        typescript: "^5.3.0",
+        webpack: "^5.89.0",
+        "webpack-cli": "^5.1.4",
+        "webpack-dev-server": "^5.2.0"
+      },
+      engines: { node: ">=18.0.0" }
+    },
+    null,
+    "	"
+  );
+}
+var TSCONFIG = `{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "outDir": "./dist",
+    "rootDir": "."
+  },
+  "include": ["app/**/*", "node-ssr/**/*", "scripts/**/*"],
+  "exclude": ["node_modules", "dist", "static"]
+}
+`;
+var NOT_FOUND_PAGE = `import React from "react";
+
+const NotFoundPage = () => (
+  <div style={{ textAlign: "center", padding: "4rem 2rem", color: "#e2e8f0" }}>
+    <h1 style={{ fontSize: "2rem", color: "#a855f7" }}>404</h1>
+    <p style={{ marginTop: "1rem", color: "#94a3b8" }}>Page not found.</p>
+  </div>
+);
+
+export default NotFoundPage;
+`;
+var DEFAULT_APP = `import React from "react";
+
+export function DefaultApp({ Component, pageProps }: any) {
+    return <Component {...pageProps} />;
+}
+`;
+var DEFAULT_DOCUMENT = `import React from "react";
+
+const isDev = process.env.NODE_ENV === "development";
+const BUNDLE_SRC = isDev
+    ? "http://localhost:3100/static/js/bundle.js"
+    : "/static/js/bundle.js";
+
+export function DefaultDocument({ children, initialProps }: any) {
+    return (
+        <html lang="en">
+            <head>
+                <meta charSet="UTF-8" />
+                <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+                <title>Blumen App</title>
+            </head>
+            <body>
+                <div id="root">{children}</div>
+                <script
+                    id="ssr-props"
+                    type="application/json"
+                    dangerouslySetInnerHTML={{
+                        __html: JSON.stringify(initialProps).replace(/</g, '\\\\u003c')
+                    }}
+                />
+                <script src={BUNDLE_SRC} defer></script>
+            </body>
+        </html>
+    );
+}
+`;
+var WEBPACK_CONFIG = [
+  "import path from 'path';",
+  "import { fileURLToPath } from 'url';",
+  "import ReactRefreshWebpackPlugin from '@pmmmwh/react-refresh-webpack-plugin';",
+  "",
+  "const __filename = fileURLToPath(import.meta.url);",
+  "const __dirname = path.dirname(__filename);",
+  "const HMR_PORT = 3100;",
+  "",
+  "const config = (env, argv) => {",
+  "  const isDev = argv.mode === 'development';",
+  "  return {",
+  "    entry: './app/client/entry.tsx',",
+  "    output: {",
+  "      filename: 'bundle.js',",
+  "      path: path.resolve(__dirname, 'static', 'js'),",
+  "      publicPath: isDev ? `http://localhost:${HMR_PORT}/static/js/` : '/static/js/',",
+  "    },",
+  "    module: {",
+  "      rules: [{",
+  "        test: /\\.tsx?$/,",
+  "        use: {",
+  "          loader: 'babel-loader',",
+  "          options: {",
+  "            presets: [",
+  "              ['@babel/preset-env', { targets: { esmodules: true } }],",
+  "              ['@babel/preset-react', { runtime: 'automatic' }],",
+  "              '@babel/preset-typescript',",
+  "            ],",
+  "            plugins: isDev ? ['react-refresh/babel'] : [],",
+  "          },",
+  "        },",
+  "        exclude: /node_modules/,",
+  "      }],",
+  "    },",
+  "    resolve: { extensions: ['.tsx', '.ts', '.js'] },",
+  "    mode: isDev ? 'development' : 'production',",
+  "    devtool: isDev ? 'eval-source-map' : 'source-map',",
+  "    optimization: { minimize: !isDev },",
+  "    plugins: isDev ? [new ReactRefreshWebpackPlugin({ overlay: false })] : [],",
+  "    ...(isDev && {",
+  "      devServer: {",
+  "        port: HMR_PORT,",
+  "        hot: true,",
+  "        headers: { 'Access-Control-Allow-Origin': '*' },",
+  "        allowedHosts: 'all',",
+  "        static: false,",
+  "        client: { webSocketURL: `ws://localhost:${HMR_PORT}/ws` },",
+  "      },",
+  "    }),",
+  "  };",
+  "};",
+  "",
+  "export default config;",
+  ""
+].join("\n");
+var LINK_TSX = `import React, { useContext } from "react";
+import { RouterContextRef } from "./RouterContext";
+
+interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+  href: string;
+}
+
+function isExternal(href: string): boolean {
+  return /^https?:\\/\\//.test(href) || href.startsWith("mailto:") || href.startsWith("tel:");
+}
+
+function isModifiedClick(e: React.MouseEvent): boolean {
+  return e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0;
+}
+
+export function Link({ href, children, onClick, target, ...rest }: LinkProps) {
+  const ctx = useContext(RouterContextRef);
+  if (!ctx) return <a href={href} target={target} {...rest}>{children}</a>;
+
+  const { navigate } = ctx;
+  const handleClick = (e: React.MouseEvent<HTMLAnchorElement>) => {
+    if (onClick) onClick(e);
+    if (e.defaultPrevented) return;
+    if (isExternal(href) || target === "_blank" || isModifiedClick(e)) return;
+    e.preventDefault();
+    navigate(href);
+  };
+
+  return <a href={href} onClick={handleClick} target={target} {...rest}>{children}</a>;
+}
+
+export default Link;
+`;
+function writeFile(base, relPath, content) {
+  const fullPath = path.join(base, relPath);
+  fs2.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs2.writeFileSync(fullPath, content, "utf-8");
+}
+function getTemplateFiles(projectName) {
+  return [
+    // Generated config
+    ["package.json", pkgJson(projectName)],
+    ["tsconfig.json", TSCONFIG],
+    ["webpack.config.js", WEBPACK_CONFIG],
+    // Embedded simple templates
+    ["app/pages/NotFound.tsx", NOT_FOUND_PAGE],
+    ["app/shared/DefaultApp.tsx", DEFAULT_APP],
+    ["app/shared/DefaultDocument.tsx", DEFAULT_DOCUMENT],
+    ["app/shared/Link.tsx", LINK_TSX],
+    // Complex files — copied from the framework source (avoids escaping hell)
+    ["app/pages/Home.tsx", readProjectFile("app/pages/BlumenStarter.tsx")],
+    ["app/shared/RouterContext.tsx", readProjectFile("app/shared/RouterContext.tsx")],
+    ["app/shared/router.ts", readProjectFile("app/shared/router.ts")],
+    ["app/client/entry.tsx", readProjectFile("app/client/entry.tsx")],
+    ["node-ssr/server.ts", readProjectFile("node-ssr/server.ts")],
+    ["go-server/main.go", readProjectFile("go-server/main.go")],
+    ["scripts/generate-routes.ts", readProjectFile("scripts/generate-routes.ts")],
+    // Placeholder
+    ["static/js/.gitkeep", ""]
+  ];
+}
+async function create(projectName) {
+  banner();
+  log.info("Create a new Blumen project\n");
+  if (!projectName) {
+    log.error("Please provide a project name.");
+    console.log(
+      `
+  ${c.dim}Usage:${c.reset} blumen create ${c.cyan}<project-name>${c.reset}
+`
+    );
+    process.exit(1);
+  }
+  const projectDir = path.resolve(process.cwd(), projectName);
+  if (fs2.existsSync(projectDir)) {
+    log.error(`Directory ${c.bold}${projectName}${c.reset} already exists.`);
+    process.exit(1);
+  }
+  const pkgManager = await select("Which package manager do you want to use?", [
+    "npm",
+    "yarn",
+    "pnpm",
+    "bun"
+  ]);
+  log.blank();
+  divider();
+  log.blank();
+  log.step(`Creating project in ${c.cyan}${projectName}${c.reset}...`);
+  const files = getTemplateFiles(projectName);
+  for (const [relPath, content] of files) {
+    writeFile(projectDir, relPath, content);
+  }
+  log.success(`${files.length} files written`);
+  log.step(`Installing dependencies with ${c.bold}${pkgManager}${c.reset}...`);
+  const installCmd = {
+    npm: "npm install",
+    yarn: "yarn",
+    pnpm: "pnpm install",
+    bun: "bun install"
+  };
+  try {
+    execSync3(installCmd[pkgManager], {
+      cwd: projectDir,
+      stdio: "inherit"
+    });
+    log.success("Dependencies installed");
+  } catch {
+    log.warn(
+      "Could not install dependencies. Run the install command manually."
+    );
+  }
+  log.blank();
+  divider();
+  log.blank();
+  log.success(`${c.bold}Project created!${c.reset}`);
+  log.blank();
+  const runCmd = {
+    npm: "npm run dev",
+    yarn: "yarn dev",
+    pnpm: "pnpm dev",
+    bun: "bun dev"
+  };
+  console.log(`  ${c.dim}Next steps:${c.reset}`);
+  console.log(`    cd ${projectName}`);
+  console.log(`    ${runCmd[pkgManager]}`);
+  log.blank();
+}
+
+// cli/blumen.ts
+var VERSION = "0.1.0";
+async function main() {
+  const command = process.argv[2];
+  if (!command || command === "--help" || command === "-h") {
+    banner();
+    console.log(
+      `  ${c.bold}Usage${c.reset}   blumen ${c.dim}<command>${c.reset}
+`
+    );
+    console.log(`  ${c.bold}Commands${c.reset}`);
+    console.log(
+      `    dev        Start development server with HMR`
+    );
+    console.log(`    build      Create a production build`);
+    console.log(`    start      Start the production server`);
+    console.log(
+      `    create     Scaffold a new Blumen project`
+    );
+    console.log("");
+    console.log(`  ${c.bold}Options${c.reset}`);
+    console.log(`    --help     Show this help message`);
+    console.log(`    --version  Show version number`);
+    console.log("");
+    return;
+  }
+  if (command === "--version" || command === "-v") {
+    console.log(`blumen v${VERSION}`);
+    return;
+  }
+  switch (command) {
+    case "dev":
+      await dev();
+      break;
+    case "build":
+      await build();
+      break;
+    case "start":
+      await start();
+      break;
+    case "create":
+      await create(process.argv[3]);
+      break;
+    default:
+      log.error(
+        `Unknown command: ${c.bold}${command}${c.reset}`
+      );
+      log.info(
+        `Run ${c.bold}blumen --help${c.reset} for available commands.`
+      );
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  log.error(err.message || String(err));
+  process.exit(1);
+});