blumenjs 0.2.1 → 0.2.3

package/dist/cli/commands/audit.js

@@ -0,0 +1,204 @@
+// cli/commands/audit.ts
+import { execSync } from "child_process";
+
+// cli/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+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 getVersion() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    let dir = path.dirname(thisFile);
+    for (let i = 0; i < 5; i++) {
+      const pkgFile = path.join(dir, "package.json");
+      if (fs.existsSync(pkgFile)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+        if (pkg.name === "blumenjs" || pkg.name === "go-react-ssr") {
+          return pkg.version;
+        }
+      }
+      dir = path.dirname(dir);
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function banner() {
+  const version = getVersion();
+  console.log("");
+  console.log(
+    `  ${c.magenta}${c.bold}\u{1F338} Blumen${c.reset} ${c.dim}v${version}${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}`);
+}
+
+// cli/commands/audit.ts
+function severityColor(severity) {
+  switch (severity) {
+    case "critical":
+      return c.red;
+    case "high":
+      return c.red;
+    case "moderate":
+      return c.yellow;
+    case "low":
+      return c.dim;
+    default:
+      return c.dim;
+  }
+}
+function severityIcon(severity) {
+  switch (severity) {
+    case "critical":
+      return "\u{1F534}";
+    case "high":
+      return "\u{1F7E0}";
+    case "moderate":
+      return "\u{1F7E1}";
+    case "low":
+      return "\u{1F535}";
+    default:
+      return "\u26AA";
+  }
+}
+async function audit(args = []) {
+  banner();
+  const fix = args.includes("--fix");
+  const ci = args.includes("--ci");
+  const jsonOutput = args.includes("--json");
+  if (fix) {
+    log.info("Attempting to fix vulnerabilities...");
+    log.blank();
+    try {
+      execSync("npm audit fix", {
+        stdio: "inherit",
+        cwd: process.cwd()
+      });
+      log.blank();
+      log.success("Audit fix completed.");
+    } catch {
+      log.warn("Some vulnerabilities could not be fixed automatically.");
+      log.info(`Run ${c.bold}npm audit fix --force${c.reset} to force-fix (may include breaking changes).`);
+    }
+    return;
+  }
+  if (jsonOutput) {
+    try {
+      execSync("npm audit --json", {
+        stdio: "inherit",
+        cwd: process.cwd()
+      });
+    } catch {
+      process.exit(1);
+    }
+    return;
+  }
+  log.info("Scanning dependencies for known vulnerabilities...");
+  log.blank();
+  let auditOutput;
+  let hasVulnerabilities = false;
+  try {
+    auditOutput = execSync("npm audit --json 2>/dev/null", {
+      cwd: process.cwd(),
+      encoding: "utf-8"
+    });
+  } catch (err) {
+    auditOutput = err.stdout || "{}";
+    hasVulnerabilities = true;
+  }
+  try {
+    const report = JSON.parse(auditOutput);
+    const meta = report.metadata || {};
+    const vulns = meta.vulnerabilities || {
+      info: 0,
+      low: 0,
+      moderate: 0,
+      high: 0,
+      critical: 0,
+      total: 0
+    };
+    const deps = meta.dependencies || {};
+    const total = vulns.total || vulns.critical + vulns.high + vulns.moderate + vulns.low + (vulns.info || 0);
+    divider();
+    log.blank();
+    if (total === 0) {
+      log.success(`${c.bold}No vulnerabilities found!${c.reset} \u2728`);
+      log.blank();
+      if (deps.total) {
+        log.info(`Scanned ${c.bold}${deps.total}${c.reset} dependencies.`);
+      }
+    } else {
+      log.warn(`${c.bold}${total} vulnerabilit${total === 1 ? "y" : "ies"} found${c.reset}`);
+      log.blank();
+      const levels = [
+        { name: "critical", count: vulns.critical },
+        { name: "high", count: vulns.high },
+        { name: "moderate", count: vulns.moderate },
+        { name: "low", count: vulns.low }
+      ];
+      for (const level of levels) {
+        if (level.count > 0) {
+          const color = severityColor(level.name);
+          const icon = severityIcon(level.name);
+          console.log(`  ${icon}  ${color}${level.count} ${level.name}${c.reset}`);
+        }
+      }
+      log.blank();
+      if (deps.total) {
+        log.info(`Scanned ${c.bold}${deps.total}${c.reset} dependencies.`);
+      }
+      log.info(`Run ${c.bold}blumen audit --fix${c.reset} to attempt automatic fixes.`);
+    }
+    log.blank();
+    divider();
+    log.blank();
+    if (ci && (vulns.critical > 0 || vulns.high > 0)) {
+      log.error("CI check failed: high or critical vulnerabilities detected.");
+      process.exit(1);
+    }
+  } catch {
+    log.info("Detailed report:");
+    log.blank();
+    try {
+      execSync("npm audit", {
+        stdio: "inherit",
+        cwd: process.cwd()
+      });
+    } catch {
+      if (ci) {
+        process.exit(1);
+      }
+    }
+  }
+}
+export {
+  audit
+};

package/dist/cli/commands/bench.js

@@ -0,0 +1,227 @@
+// cli/commands/bench.ts
+import * as http from "http";
+
+// cli/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+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 getVersion() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    let dir = path.dirname(thisFile);
+    for (let i = 0; i < 5; i++) {
+      const pkgFile = path.join(dir, "package.json");
+      if (fs.existsSync(pkgFile)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+        if (pkg.name === "blumenjs" || pkg.name === "go-react-ssr") {
+          return pkg.version;
+        }
+      }
+      dir = path.dirname(dir);
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function banner() {
+  const version = getVersion();
+  console.log("");
+  console.log(
+    `  ${c.magenta}${c.bold}\u{1F338} Blumen${c.reset} ${c.dim}v${version}${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}`);
+}
+
+// cli/commands/bench.ts
+function percentile(sorted, p) {
+  const idx = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+function makeRequest(url) {
+  return new Promise((resolve, reject) => {
+    const start = performance.now();
+    const req = http.get(url, (res) => {
+      let body = "";
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => {
+        resolve({
+          latency: performance.now() - start,
+          status: res.statusCode || 0,
+          cacheHeader: res.headers["x-blumen-cache"] || ""
+        });
+      });
+    });
+    req.on("error", reject);
+    req.setTimeout(1e4, () => {
+      req.destroy();
+      reject(new Error("Timeout"));
+    });
+  });
+}
+async function runBenchmark(url, totalRequests, concurrency) {
+  const latencies = [];
+  let successful = 0;
+  let failed = 0;
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  let streamed = 0;
+  let completed = 0;
+  const start = performance.now();
+  for (let i = 0; i < totalRequests; i += concurrency) {
+    const batchSize = Math.min(concurrency, totalRequests - i);
+    const batch = Array.from(
+      { length: batchSize },
+      () => makeRequest(url).then((result) => {
+        latencies.push(result.latency);
+        if (result.status >= 200 && result.status < 400) {
+          successful++;
+        } else {
+          failed++;
+        }
+        if (result.cacheHeader === "HIT" || result.cacheHeader === "STALE")
+          cacheHits++;
+        else if (result.cacheHeader === "MISS")
+          cacheMisses++;
+        else if (result.cacheHeader === "STREAM")
+          streamed++;
+        completed++;
+      }).catch(() => {
+        failed++;
+        completed++;
+      })
+    );
+    await Promise.all(batch);
+    const pct = Math.round(completed / totalRequests * 100);
+    process.stdout.write(`\r  \u25CF  Progress: ${pct}% (${completed}/${totalRequests})`);
+  }
+  process.stdout.write("\r" + " ".repeat(60) + "\r");
+  const totalTimeMs = performance.now() - start;
+  const sorted = latencies.sort((a, b) => a - b);
+  return {
+    url,
+    totalRequests,
+    successfulRequests: successful,
+    failedRequests: failed,
+    totalTimeMs,
+    requestsPerSec: successful / totalTimeMs * 1e3,
+    latencies: sorted,
+    p50: sorted.length ? percentile(sorted, 50) : 0,
+    p95: sorted.length ? percentile(sorted, 95) : 0,
+    p99: sorted.length ? percentile(sorted, 99) : 0,
+    min: sorted.length ? sorted[0] : 0,
+    max: sorted.length ? sorted[sorted.length - 1] : 0,
+    avg: sorted.length ? sorted.reduce((a, b) => a + b, 0) / sorted.length : 0,
+    cacheHits,
+    cacheMisses,
+    streamed
+  };
+}
+function formatMs(ms) {
+  if (ms < 1)
+    return `${(ms * 1e3).toFixed(0)}\xB5s`;
+  if (ms < 1e3)
+    return `${ms.toFixed(1)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function printResult(result) {
+  console.log(`  ${c.bold}URL${c.reset}             ${result.url}`);
+  console.log(`  ${c.bold}Requests${c.reset}        ${result.successfulRequests}/${result.totalRequests} successful${result.failedRequests > 0 ? ` (${result.failedRequests} failed)` : ""}`);
+  console.log(`  ${c.bold}Duration${c.reset}        ${formatMs(result.totalTimeMs)}`);
+  console.log(`  ${c.bold}Throughput${c.reset}      ${c.green}${result.requestsPerSec.toFixed(1)} req/sec${c.reset}`);
+  console.log("");
+  console.log(`  ${c.bold}Latency${c.reset}`);
+  console.log(`    min         ${formatMs(result.min)}`);
+  console.log(`    avg         ${formatMs(result.avg)}`);
+  console.log(`    p50         ${formatMs(result.p50)}`);
+  console.log(`    p95         ${c.yellow}${formatMs(result.p95)}${c.reset}`);
+  console.log(`    p99         ${c.yellow}${formatMs(result.p99)}${c.reset}`);
+  console.log(`    max         ${formatMs(result.max)}`);
+  if (result.cacheHits > 0 || result.cacheMisses > 0 || result.streamed > 0) {
+    console.log("");
+    console.log(`  ${c.bold}Cache${c.reset}`);
+    if (result.cacheHits > 0)
+      console.log(`    HIT         ${result.cacheHits} (${(result.cacheHits / result.totalRequests * 100).toFixed(0)}%)`);
+    if (result.cacheMisses > 0)
+      console.log(`    MISS        ${result.cacheMisses}`);
+    if (result.streamed > 0)
+      console.log(`    STREAM      ${result.streamed}`);
+  }
+}
+async function bench(args = []) {
+  banner();
+  let baseUrl = "http://localhost:3000";
+  let totalRequests = 200;
+  let concurrency = 10;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--url" && args[i + 1]) {
+      baseUrl = args[++i];
+    } else if (args[i] === "--requests" && args[i + 1]) {
+      totalRequests = parseInt(args[++i], 10);
+    } else if (args[i] === "--concurrency" && args[i + 1]) {
+      concurrency = parseInt(args[++i], 10);
+    }
+  }
+  log.info(`Benchmarking ${c.bold}${baseUrl}${c.reset}`);
+  log.info(`${totalRequests} requests, ${concurrency} concurrent connections`);
+  log.blank();
+  divider();
+  const endpoints = [
+    { name: "Homepage (SSR)", path: "/" },
+    { name: "About (SSR)", path: "/about" },
+    { name: "Static Asset", path: "/static/js/runtime.js" }
+  ];
+  for (const endpoint of endpoints) {
+    const url = `${baseUrl}${endpoint.path}`;
+    log.blank();
+    console.log(`  ${c.bold}${c.cyan}\u25B8 ${endpoint.name}${c.reset}`);
+    log.blank();
+    try {
+      const result = await runBenchmark(url, totalRequests, concurrency);
+      printResult(result);
+    } catch (err) {
+      log.error(`  Failed to benchmark ${url}: ${err.message}`);
+      log.info(`  Make sure the server is running (${c.bold}blumen dev${c.reset} or ${c.bold}blumen start${c.reset})`);
+    }
+    log.blank();
+    divider();
+  }
+  log.blank();
+  log.success("Benchmark complete! \u2728");
+  log.blank();
+  log.info(`For production load testing, use k6:`);
+  log.info(`  ${c.bold}k6 run benchmarks/k6-load-test.js${c.reset}`);
+  log.blank();
+}
+export {
+  bench
+};

package/dist/cli/commands/build.js

@@ -1,5 +1,7 @@
 // cli/commands/build.ts
 import { execSync } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
 
 // cli/utils.ts
 import * as fs from "fs";
@@ -61,6 +63,37 @@ function divider() {
 }
 
 // cli/commands/build.ts
+function generateChunkManifest() {
+  const jsDir = path2.resolve("static/js");
+  const chunksDir = path2.resolve("static/js/chunks");
+  const manifest = {};
+  if (fs2.existsSync(jsDir)) {
+    for (const file of fs2.readdirSync(jsDir)) {
+      if (!file.endsWith(".js") || file.endsWith(".map"))
+        continue;
+      const match = file.match(/^([^.]+)\.[a-f0-9]+\.js$/);
+      if (match) {
+        manifest[match[1]] = `/static/js/${file}`;
+      }
+    }
+  }
+  if (fs2.existsSync(chunksDir)) {
+    for (const file of fs2.readdirSync(chunksDir)) {
+      if (!file.endsWith(".js") || file.endsWith(".map"))
+        continue;
+      const match = file.match(/^([^.]+)\.[a-f0-9]+\.js$/);
+      if (match) {
+        manifest[match[1]] = `/static/js/chunks/${file}`;
+      }
+    }
+  }
+  fs2.mkdirSync("dist", { recursive: true });
+  fs2.writeFileSync("dist/chunk-manifest.json", JSON.stringify(manifest, null, 2));
+  const coreChunks = ["runtime", "vendor", "framework", "main"].filter((k) => manifest[k]);
+  const pageChunks = Object.keys(manifest).filter((k) => k.startsWith("page-"));
+  log.info(`  Core chunks: ${coreChunks.join(", ")} (${coreChunks.length})`);
+  log.info(`  Page chunks: ${pageChunks.length} page(s)`);
+}
 async function build(args = []) {
   banner();
   const analyze = args.includes("--analyze");
@@ -75,10 +108,14 @@ async function build(args = []) {
       cmd: "npx tsx scripts/generate-routes.ts"
     },
     {
-      label: "Building client bundle",
+      label: "Building client bundle (code splitting)",
       cmd: "npx webpack --mode production",
       env: analyze ? { BLUMEN_ANALYZE: "1" } : void 0
     },
+    {
+      label: "Generating chunk manifest",
+      fn: generateChunkManifest
+    },
     {
       label: "Building SSR server",
       cmd: "npx esbuild node-ssr/server.ts --bundle --platform=node --format=esm --outfile=dist/ssr-server.js --packages=external --alias:@=./app"
@@ -95,11 +132,15 @@ async function build(args = []) {
     const step = steps[i];
     log.step(`[${i + 1}/${steps.length}] ${step.label}...`);
     try {
-      execSync(step.cmd, {
-        stdio: "inherit",
-        cwd: process.cwd(),
-        env: { ...process.env, ...step.env || {} }
-      });
+      if (step.fn) {
+        step.fn();
+      } else if (step.cmd) {
+        execSync(step.cmd, {
+          stdio: "inherit",
+          cwd: process.cwd(),
+          env: { ...process.env, ...step.env || {} }
+        });
+      }
       log.success(step.label);
     } catch {
       if (step.optional) {