gorsee 0.2.3 → 0.2.5

package/dist-pkg/cli/cmd-build.js

@@ -0,0 +1,198 @@
+import { join } from "node:path";
+import { mkdir, rm, writeFile, readdir, stat, watch } from "node:fs/promises";
+import { createRouter } from "../router/scanner.js";
+import { buildClientBundles } from "../build/client.js";
+import { configureClientBuildBackend } from "../build/client-backend.js";
+import { initializeBuildBackends } from "../build/init.js";
+import { generateStaticPages } from "../build/ssg.js";
+import { createBuildManifest } from "../build/manifest.js";
+import { createHash } from "node:crypto";
+import { wrapHTML } from "../server/html-shell.js";
+import { createProjectContext } from "../runtime/project.js";
+import { buildServerArtifacts } from "../build/server-bundle.js";
+import {
+  configureAIObservability,
+  emitAIDiagnostic,
+  emitAIEvent,
+  resolveAIObservabilityConfig,
+  runWithAITrace
+} from "../ai/index.js";
+import { loadAppConfig, resolveAIConfig } from "../runtime/app-config.js";
+import { initializeCompilerBackends } from "../compiler/init.js";
+async function hashFile(path) {
+  const content = await Bun.file(path).arrayBuffer();
+  return createHash("sha256").update(new Uint8Array(content)).digest("hex").slice(0, 8);
+}
+async function getAllFiles(dir) {
+  const files = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: !0 });
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory())
+        files.push(...await getAllFiles(full));
+      else
+        files.push(full);
+    }
+  } catch {}
+  return files;
+}
+export async function buildProject(options = {}) {
+  const { cwd, paths } = createProjectContext(options);
+  initializeCompilerBackends(options.env ?? process.env);
+  initializeBuildBackends(options.env ?? process.env);
+  const appConfig = await loadAppConfig(cwd);
+  configureAIObservability(resolveAIConfig(cwd, appConfig, options.ai) ?? resolveAIObservabilityConfig(cwd));
+  try {
+    await runWithAITrace({
+      kind: "build.project",
+      severity: "info",
+      source: "build",
+      message: "production build",
+      phase: "build",
+      data: { cwd, minify: options.minify ?? !0, sourcemap: options.sourcemap ?? !0 }
+    }, async () => {
+      const startTime = performance.now();
+      console.log(`
+  Gorsee Build
+`);
+      await rm(paths.distDir, { recursive: !0, force: !0 });
+      await mkdir(paths.clientDir, { recursive: !0 });
+      await mkdir(paths.serverDir, { recursive: !0 });
+      const routes = await createRouter(paths.routesDir);
+      console.log(`  [1/5] Found ${routes.length} route(s)`);
+      await emitAIEvent({
+        kind: "build.phase",
+        severity: "info",
+        source: "build",
+        message: "routes scanned",
+        phase: "scan-routes",
+        data: { routes: routes.length }
+      });
+      const build = await buildClientBundles(routes, cwd, {
+        minify: options.minify ?? !0,
+        sourcemap: options.sourcemap ?? !0,
+        backend: options.clientBuildBackend ?? configureClientBuildBackend(options.env ?? process.env)
+      });
+      console.log(`  [2/5] Client bundles built (${build.entryMap.size} entries)`);
+      await emitAIEvent({
+        kind: "build.phase",
+        severity: "info",
+        source: "build",
+        message: "client bundles built",
+        phase: "client-bundles",
+        data: { entries: build.entryMap.size }
+      });
+      const clientSrc = join(paths.gorseeDir, "client"), clientFiles = await getAllFiles(clientSrc), hashMap = new Map;
+      for (const file of clientFiles) {
+        const rel = file.slice(clientSrc.length + 1), preserveRuntimePath = rel.startsWith("chunks/") || rel.endsWith(".map"), hash = preserveRuntimePath ? null : await hashFile(file), ext = rel.lastIndexOf("."), hashed = preserveRuntimePath ? rel : ext > 0 ? `${rel.slice(0, ext)}.${hash}${rel.slice(ext)}` : `${rel}.${hash}`, dest = join(paths.clientDir, hashed);
+        await mkdir(join(dest, ".."), { recursive: !0 });
+        await Bun.write(dest, Bun.file(file));
+        hashMap.set(rel, hashed);
+      }
+      console.log(`  [3/5] Assets hashed (${hashMap.size} files)`);
+      const manifest = await createBuildManifest(routes, build.entryMap, hashMap);
+      await writeFile(join(paths.distDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+      const serverArtifacts = await buildServerArtifacts(cwd, paths.distDir);
+      console.log("  [4/5] Manifest + server entries generated");
+      const ssgResult = await generateStaticPages({
+        routesDir: paths.routesDir,
+        outDir: join(paths.distDir, "static"),
+        wrapHTML: (body, htmlOptions = {}) => wrapHTML(body, void 0, htmlOptions)
+      }), finalManifest = ssgResult.pages.size > 0 ? await createBuildManifest(routes, build.entryMap, hashMap, ssgResult.pages.keys()) : manifest;
+      if (ssgResult.pages.size > 0)
+        await writeFile(join(paths.distDir, "manifest.json"), JSON.stringify(finalManifest, null, 2));
+      if (ssgResult.errors.length > 0) {
+        for (const err of ssgResult.errors)
+          console.error(`  SSG error: ${err}`);
+        for (const err of ssgResult.errors)
+          await emitAIEvent({
+            kind: "diagnostic.issue",
+            severity: "error",
+            source: "build",
+            message: err,
+            code: "SSG",
+            phase: "ssg"
+          });
+      }
+      console.log(`  [5/5] SSG: ${ssgResult.pages.size} page(s) pre-rendered`);
+      let totalSize = 0;
+      for (const file of await getAllFiles(paths.clientDir)) {
+        const s = await stat(file);
+        totalSize += s.size;
+      }
+      const elapsed = ((performance.now() - startTime) / 1000).toFixed(2);
+      console.log();
+      console.log("  Output: dist/");
+      console.log(`  Client size: ${(totalSize / 1024).toFixed(1)} KB`);
+      console.log(`  Built in ${elapsed}s`);
+      console.log();
+      await emitAIEvent({
+        kind: "build.summary",
+        severity: ssgResult.errors.length > 0 ? "warn" : "info",
+        source: "build",
+        message: "build completed",
+        phase: "summary",
+        data: {
+          artifact: "dist/",
+          routes: routes.length,
+          entries: build.entryMap.size,
+          assets: hashMap.size,
+          serverEntries: serverArtifacts.serverEntries,
+          prerenderedPages: ssgResult.pages.size,
+          ssgErrors: ssgResult.errors.length,
+          clientKb: Number((totalSize / 1024).toFixed(1)),
+          elapsedSeconds: Number(elapsed)
+        }
+      });
+    });
+  } catch (error) {
+    await emitAIDiagnostic({
+      code: "BUILD_FAILURE",
+      message: error instanceof Error ? error.message : String(error),
+      severity: "error",
+      source: "build",
+      fix: "Inspect structured build diagnostics, build backend logs, and docs/BUILD_DIAGNOSTICS.md."
+    });
+    throw error;
+  }
+}
+export async function watchBuildProject(options = {}) {
+  const { paths } = createProjectContext(options);
+  console.log(`
+  Gorsee Build --watch
+`);
+  console.log("  Performing initial build...");
+  await buildProject(options);
+  let building = !1, queued = !1;
+  async function rebuild() {
+    if (building) {
+      queued = !0;
+      return;
+    }
+    building = !0;
+    try {
+      const start = performance.now();
+      await buildProject(options);
+      const ms = (performance.now() - start).toFixed(0);
+      console.log(`  Rebuilt in ${ms}ms`);
+    } catch (err) {
+      console.error("  Build error:", err);
+    } finally {
+      building = !1;
+      if (queued) {
+        queued = !1;
+        await rebuild();
+      }
+    }
+  }
+  console.log("  Watching for changes...");
+  const watcher = watch(paths.routesDir, { recursive: !0 });
+  for await (const _event of watcher)
+    await rebuild();
+}
+export async function runBuild(args, options = {}) {
+  if (args.includes("--watch"))
+    return watchBuildProject(options);
+  return buildProject(options);
+}

package/dist-pkg/cli/cmd-check.d.ts

@@ -0,0 +1,25 @@
+import { type RuntimeOptions } from "../runtime/project.js";
+import { type AIObservabilityConfig } from "../ai/index.js";
+interface CheckResult {
+    errors: CheckIssue[];
+    warnings: CheckIssue[];
+    info: string[];
+}
+interface CheckIssue {
+    code: string;
+    file: string;
+    line?: number;
+    message: string;
+    fix?: string;
+}
+export type { CheckResult, CheckIssue };
+export interface CheckCommandOptions extends RuntimeOptions {
+    runTypeScript?: boolean;
+    strictSecurity?: boolean;
+    ai?: AIObservabilityConfig;
+    rewriteImports?: boolean;
+    rewriteLoaders?: boolean;
+}
+export declare function checkProject(options?: CheckCommandOptions): Promise<CheckResult>;
+/** @deprecated Use checkProject() for programmatic access. */
+export declare function runCheck(args: string[], options?: CheckCommandOptions): Promise<void>;