@arcote.tech/arc-cli 0.3.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-cli",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "CLI tool for Arc framework",
   "module": "index.ts",
   "main": "dist/index.js",
@@ -9,7 +9,7 @@
     "arc": "./dist/index.js"
   },
   "scripts": {
-    "build": "bun build --target=node ./src/index.ts --outdir=dist && chmod +x dist/index.js"
+    "build": "bun build --target=bun ./src/index.ts --outdir=dist --external @arcote.tech/arc --external @arcote.tech/arc-ds --external @arcote.tech/arc-react --external @arcote.tech/platform && chmod +x dist/index.js"
   },
   "dependencies": {
     "commander": "^11.1.0",

package/src/builder/module-builder.ts

@@ -0,0 +1,348 @@
+import { execSync } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+} from "fs";
+import { dirname, join, relative } from "path";
+import {
+  buildTypeDeclarations,
+  type DeclarationResult,
+} from "../utils/build";
+import { i18nExtractPlugin, finalizeTranslations } from "../i18n";
+
+/** Clients that a context package is built for. */
+const CONTEXT_CLIENTS = [
+  { name: "server", target: "bun" as const, defines: { ONLY_SERVER: "true", ONLY_BROWSER: "false", ONLY_CLIENT: "false" } },
+  { name: "browser", target: "browser" as const, defines: { ONLY_SERVER: "false", ONLY_BROWSER: "true", ONLY_CLIENT: "true" } },
+];
+
+/**
+ * Build a context package (browser/server split) using Bun.build directly,
+ * then generate .d.ts declarations via tsgo (with tsc fallback).
+ *
+ * Returns declaration errors (if any) so the caller can display them.
+ */
+async function buildContextPackage(
+  pkg: WorkspacePackage,
+): Promise<{ declarationErrors: string[] }> {
+  const entrypoint = pkg.entrypoint;
+  const outDir = join(pkg.path, "dist");
+  const peerDeps = Object.keys(pkg.packageJson.peerDependencies || {});
+  const deps = Object.keys(pkg.packageJson.dependencies || {});
+  const externals = [...peerDeps, ...deps];
+  const allDeclErrors: string[] = [];
+
+  for (const client of CONTEXT_CLIENTS) {
+    // JS bundle
+    const result = await Bun.build({
+      entrypoints: [entrypoint],
+      outdir: join(outDir, client.name, "main"),
+      target: client.target,
+      format: "esm",
+      naming: "index.[ext]",
+      external: externals,
+      define: client.defines,
+    });
+
+    if (!result.success) {
+      console.error(`Context ${client.name} build failed:`);
+      for (const log of result.logs) console.error(log);
+      throw new Error(`${client.name} build failed for ${pkg.name}`);
+    }
+
+    // Type declarations — globals match the define values
+    const globalsContent = Object.entries(client.defines)
+      .map(([k, v]) => `declare const ${k}: ${v};`)
+      .join("\n");
+
+    const declResult = await buildTypeDeclarations(
+      [entrypoint],
+      join(outDir, client.name),
+      dirname(entrypoint),
+      globalsContent,
+    );
+
+    if (!declResult.success && declResult.errors.length > 0) {
+      allDeclErrors.push(
+        ...declResult.errors.map((e) => `[${pkg.name}/${client.name}] ${e}`),
+      );
+    }
+  }
+
+  return { declarationErrors: allDeclErrors };
+}
+
+/** Packages that shell provides — modules import them but don't bundle them. */
+export const SHELL_EXTERNALS = [
+  "react",
+  "react-dom",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "@arcote.tech/arc",
+  "@arcote.tech/arc-ds",
+  "@arcote.tech/arc-react",
+  "@arcote.tech/platform",
+];
+
+export interface WorkspacePackage {
+  name: string;
+  path: string;
+  entrypoint: string;
+  packageJson: Record<string, any>;
+}
+
+export interface BuildManifest {
+  modules: string[];
+  buildTime: string;
+}
+
+/**
+ * Discover workspace packages from root package.json.
+ * Skips @arcote.tech/* packages (those are framework, not business).
+ */
+export function discoverPackages(rootDir: string): WorkspacePackage[] {
+  const rootPkg = JSON.parse(
+    readFileSync(join(rootDir, "package.json"), "utf-8"),
+  );
+  const workspaceGlobs: string[] = rootPkg.workspaces ?? [];
+  const results: WorkspacePackage[] = [];
+
+  for (const glob of workspaceGlobs) {
+    const base = glob.replace("/*", "");
+    const baseDir = join(rootDir, base);
+    if (!existsSync(baseDir)) continue;
+
+    let entries: string[];
+    try {
+      entries = readdirSync(baseDir);
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const pkgPath = join(baseDir, entry, "package.json");
+      if (!existsSync(pkgPath)) continue;
+
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.name?.startsWith("@arcote.tech/")) continue;
+
+      // Find entrypoint: src/index.ts, src/index.tsx, or root index.ts
+      const pkgDir = join(baseDir, entry);
+      const candidates = [
+        join(pkgDir, "src", "index.ts"),
+        join(pkgDir, "src", "index.tsx"),
+        join(pkgDir, "index.ts"),
+        join(pkgDir, "index.tsx"),
+      ];
+      const entrypoint = candidates.find((c) => existsSync(c)) ?? null;
+      if (!entrypoint) continue;
+
+      results.push({
+        name: pkg.name,
+        path: join(baseDir, entry),
+        entrypoint,
+        packageJson: pkg,
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Check if a package is a context (has browser/server exports split).
+ */
+export function isContextPackage(pkg: Record<string, any>): boolean {
+  const exports = pkg.exports ?? {};
+  for (const key of Object.keys(exports)) {
+    if (key.includes("/browser") || key.includes("/server")) return true;
+    const val = exports[key];
+    if (val && typeof val === "object" && ("browser" in val || "server" in val))
+      return true;
+  }
+  return false;
+}
+
+/**
+ * Build all workspace packages as ESM chunks using Bun.build.
+ * Context packages get a wrapper that calls arc() to auto-register.
+ * Regular modules already call arc() in their source.
+ */
+export async function buildPackages(
+  rootDir: string,
+  outDir: string,
+  packages: WorkspacePackage[],
+): Promise<BuildManifest> {
+  mkdirSync(outDir, { recursive: true });
+
+  // Build contexts first (server/browser split via Bun.build + declarations)
+  const contexts = packages.filter((p) => isContextPackage(p.packageJson));
+  const allDeclErrors: string[] = [];
+  for (const ctx of contexts) {
+    console.log(`  Building context: ${ctx.name}`);
+    const { declarationErrors } = await buildContextPackage(ctx);
+    allDeclErrors.push(...declarationErrors);
+  }
+
+  if (allDeclErrors.length > 0) {
+    console.warn("\n\x1b[33mType declaration errors:\x1b[0m");
+    for (const err of allDeclErrors) {
+      console.warn(`  ${err}`);
+    }
+    console.warn("");
+  }
+
+  // Generate wrapper entries in a tmp dir
+  const tmpDir = join(outDir, "_entries");
+  mkdirSync(tmpDir, { recursive: true });
+
+  const entrypoints: string[] = [];
+
+  for (const pkg of packages) {
+    const safeName = pkg.path.split("/").pop()!;
+
+    // All packages get a simple re-export wrapper.
+    // Context packages that use module().build() self-register via side effects.
+    // Legacy packages that export appContext will be picked up by arc(() => appContext).
+    const wrapperFile = join(tmpDir, `${safeName}.ts`);
+    writeFileSync(wrapperFile, `export * from "${pkg.name}";\n`);
+    entrypoints.push(wrapperFile);
+  }
+
+  console.log(`  Bundling ${entrypoints.length} package(s)...`);
+
+  // i18n extraction — collect translatable strings during bundling
+  const i18nCollector = new Map<string, Set<string>>();
+
+  const result = await Bun.build({
+    entrypoints,
+    outdir: outDir,
+    splitting: true,
+    format: "esm",
+    target: "browser",
+    external: SHELL_EXTERNALS,
+    plugins: [i18nExtractPlugin(i18nCollector, rootDir)],
+    naming: "[name].[ext]",
+    define: {
+      ONLY_SERVER: "false",
+      ONLY_BROWSER: "true",
+      ONLY_CLIENT: "true",
+    },
+  });
+
+  if (!result.success) {
+    console.error("Build failed:");
+    for (const log of result.logs) console.error(log);
+    throw new Error("Module build failed");
+  }
+
+  // Finalize translations — merge .po catalogs + compile .json
+  // outDir is modulesDir, translations JSON goes to parent (arcDir)
+  await finalizeTranslations(rootDir, join(outDir, ".."), i18nCollector);
+
+  // Clean tmp
+  const { rmSync } = await import("fs");
+  rmSync(tmpDir, { recursive: true, force: true });
+
+  // Build manifest
+  const moduleFiles = result.outputs
+    .filter((o) => o.kind === "entry-point")
+    .map((o) => o.path.split("/").pop()!);
+
+  const manifest: BuildManifest = {
+    modules: moduleFiles,
+    buildTime: new Date().toISOString(),
+  };
+
+  writeFileSync(
+    join(outDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2),
+  );
+  return manifest;
+}
+
+/**
+ * Build CSS using tailwind CLI.
+ */
+export async function buildStyles(
+  rootDir: string,
+  outDir: string,
+): Promise<void> {
+  mkdirSync(outDir, { recursive: true });
+
+  const inputCss = join(outDir, "_input.css");
+  const outputCss = join(outDir, "styles.css");
+  const rootRel = relative(outDir, rootDir).replace(/\\/g, "/");
+
+  writeFileSync(
+    inputCss,
+    `@import "tailwindcss";
+@import "tw-animate-css";
+
+@source "${rootRel}/packages/*/*.{ts,tsx}";
+@source "${rootRel}/packages/*/src/**/*.{ts,tsx}";
+@source "${rootRel}/node_modules/@arcote.tech/platform/src/**/*.{ts,tsx}";
+@source "${rootRel}/node_modules/@arcote.tech/arc-ds/src/**/*.{ts,tsx}";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-destructive-foreground: var(--destructive-foreground);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+  --color-chart-1: var(--chart-1);
+  --color-chart-2: var(--chart-2);
+  --color-chart-3: var(--chart-3);
+  --color-chart-4: var(--chart-4);
+  --color-chart-5: var(--chart-5);
+  --color-sidebar: var(--sidebar);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-ring: var(--sidebar-ring);
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+    min-height: 100vh;
+  }
+}
+`,
+  );
+
+  console.log("  Building CSS...");
+  execSync(`bunx @tailwindcss/cli -i ${inputCss} -o ${outputCss} --minify`, {
+    cwd: rootDir,
+    stdio: "inherit",
+  });
+}

package/src/commands/platform-build.ts

@@ -0,0 +1,7 @@
+import { buildAll, ok, resolveWorkspace } from "../platform/shared";
+
+export async function platformBuild(): Promise<void> {
+  const ws = resolveWorkspace();
+  const manifest = await buildAll(ws);
+  ok(`Platform built — ${manifest.modules.length} module(s)`);
+}

package/src/commands/platform-dev.ts

@@ -0,0 +1,116 @@
+import { existsSync, watch } from "fs";
+import { join } from "path";
+import { compileAllCatalogs } from "../i18n/compile";
+import { startPlatformServer } from "../platform/server";
+import {
+  buildAll,
+  buildPackages,
+  buildStyles,
+  loadServerContext,
+  log,
+  ok,
+  resolveWorkspace,
+} from "../platform/shared";
+
+export async function platformDev(): Promise<void> {
+  const ws = resolveWorkspace();
+  const port = 5005;
+
+  // Build everything
+  let manifest = await buildAll(ws);
+
+  // Load server context
+  log("Loading server context...");
+  const context = await loadServerContext(ws.packages);
+  if (context) {
+    ok("Context loaded");
+  } else {
+    log("No context — server endpoints skipped");
+  }
+
+  // Start server (dev mode = SSE reload + no-cache)
+  const platform = await startPlatformServer({
+    ws,
+    port,
+    manifest,
+    context,
+    dbPath: join(ws.rootDir, ".arc", "data", "dev.db"),
+    devMode: true,
+  });
+
+  ok(`Server on http://localhost:${port}`);
+  if (platform.contextHandler) ok("Commands, queries, WebSocket — all on same port");
+
+  // Watch for changes
+  log("Watching for changes...");
+  let rebuildTimer: ReturnType<typeof setTimeout> | null = null;
+  let isRebuilding = false;
+
+  for (const pkg of ws.packages) {
+    const srcDir = join(pkg.path, "src");
+    if (!existsSync(srcDir)) continue;
+
+    watch(srcDir, { recursive: true }, (_event, filename) => {
+      // Ignore build artifacts and non-source files
+      if (
+        !filename ||
+        filename.includes(".arc") ||
+        filename.endsWith(".d.ts") ||
+        filename.includes("node_modules") ||
+        filename.includes("dist")
+      ) return;
+
+      // Only rebuild for source file changes
+      if (!filename.endsWith(".ts") && !filename.endsWith(".tsx")) return;
+
+      if (rebuildTimer) clearTimeout(rebuildTimer);
+      rebuildTimer = setTimeout(async () => {
+        if (isRebuilding) return;
+        isRebuilding = true;
+        log("Rebuilding...");
+        try {
+          manifest = await buildPackages(
+            ws.rootDir,
+            ws.modulesDir,
+            ws.packages,
+          );
+          await buildStyles(ws.rootDir, ws.arcDir);
+          platform.setManifest(manifest);
+          platform.notifyReload(manifest);
+          ok(`Rebuilt ${manifest.modules.length} module(s)`);
+        } catch (e) {
+          console.error(`Rebuild failed: ${e}`);
+        } finally {
+          isRebuilding = false;
+        }
+      }, 300);
+    });
+  }
+
+  // Watch locales/*.po for translation changes → recompile JSON
+  const localesDir = join(ws.rootDir, "locales");
+  if (existsSync(localesDir)) {
+    let poTimer: ReturnType<typeof setTimeout> | null = null;
+    watch(localesDir, { recursive: false }, (_event, filename) => {
+      if (!filename?.endsWith(".po")) return;
+      if (poTimer) clearTimeout(poTimer);
+      poTimer = setTimeout(async () => {
+        try {
+          compileAllCatalogs(localesDir, join(ws.arcDir, "locales"));
+          ok("Translations recompiled");
+          platform.notifyReload(manifest);
+        } catch (e) {
+          console.error(`Translation compile failed: ${e}`);
+        }
+      }, 200);
+    });
+  }
+
+  // Cleanup
+  const cleanup = () => {
+    platform.stop();
+    process.exit(0);
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+}

package/src/commands/platform-start.ts

@@ -0,0 +1,56 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { startPlatformServer } from "../platform/server";
+import {
+  err,
+  loadServerContext,
+  log,
+  ok,
+  resolveWorkspace,
+  type BuildManifest,
+} from "../platform/shared";
+
+export async function platformStart(): Promise<void> {
+  const ws = resolveWorkspace();
+  const port = parseInt(process.env.PORT || "5005", 10);
+
+  // Read pre-built manifest
+  const manifestPath = join(ws.modulesDir, "manifest.json");
+  if (!existsSync(manifestPath)) {
+    err("No build found. Run `arc platform build` first.");
+    process.exit(1);
+  }
+  const manifest: BuildManifest = JSON.parse(
+    readFileSync(manifestPath, "utf-8"),
+  );
+
+  // Load server context
+  log("Loading server context...");
+  const context = await loadServerContext(ws.packages);
+  if (context) {
+    ok("Context loaded");
+  } else {
+    log("No context — server endpoints skipped");
+  }
+
+  // Start server (production mode = no SSE reload, aggressive caching)
+  const platform = await startPlatformServer({
+    ws,
+    port,
+    manifest,
+    context,
+    dbPath: join(ws.rootDir, ".arc", "data", "prod.db"),
+    devMode: false,
+  });
+
+  ok(`Server on http://localhost:${port}`);
+  if (platform.contextHandler) ok("Commands, queries, WebSocket — all on same port");
+
+  // Cleanup
+  const cleanup = () => {
+    platform.stop();
+    process.exit(0);
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+}