@arcote.tech/arc-cli 0.3.0 → 0.4.1

package/src/utils/build.ts

@@ -1,5 +1,5 @@
 import { spawn } from "child_process";
-import { readFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import type { ArcConfig, ContextInfo } from "./config";
 import { generateClientTypes } from "./config";
@@ -23,9 +23,6 @@ export interface BuildTask {
   watch: boolean;
 }
 
-/**
- * Read package.json and extract peer dependencies
- */
 function getPeerDependencies(configDir: string): string[] {
   try {
     const packageJsonPath = join(configDir, "package.json");
@@ -36,9 +33,6 @@ function getPeerDependencies(configDir: string): string[] {
   }
 }
 
-/**
- * Get external dependencies for a specific client
- */
 function getExternals(
   config: ArcConfig,
   configDir: string,
@@ -46,27 +40,20 @@ function getExternals(
 ): string[] {
   const peerDeps = getPeerDependencies(configDir);
   const externals = new Set<string>(peerDeps);
-
   if (config.externals?.common) {
     config.externals.common.forEach((ext) => externals.add(ext));
   }
-
   const clientExternals =
     config.externals?.[client as keyof typeof config.externals];
   if (Array.isArray(clientExternals)) {
     clientExternals.forEach((ext) => externals.add(ext));
   }
-
   return Array.from(externals);
 }
 
-/**
- * Build a single context for a specific client
- */
 export async function buildContext(task: BuildTask): Promise<BuildResult> {
   const startTime = Date.now();
   const { configPath, config, context, client, watch } = task;
-
   const result: BuildResult = {
     success: false,
     context: context.name,
@@ -77,11 +64,8 @@ export async function buildContext(task: BuildTask): Promise<BuildResult> {
   };
 
   try {
-    // Build the JavaScript bundle
     await buildContextBundle(configPath, config, context, client, watch);
     result.jsBuilt = true;
-
-    // Build declarations
     if (!watch) {
       const declResult = await buildContextDeclarations(
         configPath,
@@ -92,7 +76,6 @@ export async function buildContext(task: BuildTask): Promise<BuildResult> {
       result.declarationsBuilt = declResult.success;
       result.declarationErrors = declResult.errors;
     }
-
     result.success = result.jsBuilt;
     result.duration = Date.now() - startTime;
     return result;
@@ -103,9 +86,6 @@ export async function buildContext(task: BuildTask): Promise<BuildResult> {
   }
 }
 
-/**
- * Build JavaScript bundle for a context
- */
 export async function buildContextBundle(
   configPath: string,
   config: ArcConfig,
@@ -114,66 +94,98 @@ export async function buildContextBundle(
   watch: boolean = false,
 ): Promise<void> {
   const configDir = dirname(configPath);
-
   const defineValues: Record<string, string> = {};
-
   for (const c of config.clients) {
     const normalizedC = c.toUpperCase().replace(/[^A-Z0-9]/g, "_");
     defineValues[normalizedC] = c === client ? "true" : "false";
     defineValues[`NOT_ON_${normalizedC}`] = c === client ? "false" : "true";
     defineValues[`ONLY_${normalizedC}`] = c === client ? "true" : "false";
   }
-
   const defineArgs = Object.entries(defineValues)
     .map(([key, value]) => `--define="${key}=${value}"`)
     .join(" ");
-
   const externals = getExternals(config, configDir, client);
   const externalArgs = externals.map((dep) => `--external=${dep}`).join(" ");
-
   const buildTarget = client === "browser" ? "browser" : "bun";
-
+  // JS output: dist/{client}/{context}/ (matches TypeScript declaration output)
   const outDirPath = join(
     configDir,
     config.outDir,
-    context.name,
     client.toLowerCase(),
+    context.name,
   );
-
   const command = `bun build ${context.fullPath} --target=${buildTarget} --outdir=${outDirPath} ${defineArgs} ${externalArgs}${watch ? " --watch" : ""}`;
 
   return new Promise((resolve, reject) => {
     const proc = spawn(command, { shell: true, cwd: configDir });
-
     let output = "";
     let errorOutput = "";
-
-    proc.stdout.on("data", (data) => {
+    proc.stdout.on("data", (data: Buffer) => {
       output += data.toString();
     });
-
-    proc.stderr.on("data", (data) => {
+    proc.stderr.on("data", (data: Buffer) => {
       errorOutput += data.toString();
     });
-
-    proc.on("close", (code) => {
-      if (code !== 0 && !watch) {
+    proc.on("close", (code: number) => {
+      if (code !== 0 && !watch)
         reject(new Error(`Build failed: ${errorOutput || output}`));
-      } else if (!watch) {
-        resolve();
-      }
+      else if (!watch) resolve();
     });
   });
 }
 
-interface DeclarationResult {
+export interface DeclarationResult {
   success: boolean;
   errors: string[];
 }
 
+// ---------------------------------------------------------------------------
+// Core declaration builder — reusable by both old arc.config flow and platform
+// ---------------------------------------------------------------------------
+
+/**
+ * Build type declarations using tsgo (with tsc fallback).
+ *
+ * @param files      Entry .ts/.tsx files to generate declarations for
+ * @param outDir     Output directory for .d.ts files
+ * @param rootDir    Root directory for TypeScript (controls output structure)
+ * @param globalsContent  Optional ambient declarations (ONLY_SERVER etc.) —
+ *                        written to a temp .d.ts and included in compilation.
+ */
+export async function buildTypeDeclarations(
+  files: string[],
+  outDir: string,
+  rootDir: string,
+  globalsContent?: string,
+): Promise<DeclarationResult> {
+  const allFiles = [...files];
+
+  // Write temp globals .d.ts OUTSIDE source dir to avoid triggering file watchers
+  let globalsPath: string | null = null;
+  if (globalsContent) {
+    const tmpDir = join(outDir, "_build-types");
+    mkdirSync(tmpDir, { recursive: true });
+    globalsPath = join(tmpDir, "globals.d.ts");
+    writeFileSync(globalsPath, globalsContent);
+    allFiles.push(globalsPath);
+  }
+
+  let result = await runTsgo(allFiles, outDir, rootDir);
+  if (result === null) {
+    result = await runTsc(allFiles, outDir, rootDir);
+  }
+
+  // Clean up temp globals
+  if (globalsPath && existsSync(globalsPath)) {
+    unlinkSync(globalsPath);
+  }
+
+  return result;
+}
+
 /**
- * Build declarations for a context using tsgo (TypeScript Go)
- * Falls back to regular tsc if tsgo is not available
+ * Build declarations (old arc.config flow).
+ * Output: dist/{client}/{context}/ (matches JS output and TypeScript's natural output)
  */
 export async function buildContextDeclarations(
   configPath: string,
@@ -182,61 +194,47 @@ export async function buildContextDeclarations(
   client: string,
 ): Promise<DeclarationResult> {
   const configDir = dirname(configPath);
-
-  // Generate client types
   generateClientTypes(config, configDir, client);
 
-  const outDir = join(
-    configDir,
-    config.outDir,
-    context.name,
-    client.toLowerCase(),
-  );
+  const outDir = join(configDir, config.outDir, client.toLowerCase());
 
-  // Try tsgo first, fall back to tsc
-  const tsgoResult = await runTsgo(context.fullPath, outDir, configDir);
-  if (tsgoResult !== null) {
-    return tsgoResult;
-  }
+  // Include arc.d.ts for global constants
+  const arcTypesPath = join(configDir, "arc.d.ts");
+  const files = existsSync(arcTypesPath)
+    ? [context.fullPath, arcTypesPath]
+    : [context.fullPath];
 
-  // Fallback to tsc
-  return runTsc(context.fullPath, outDir, configDir);
+  let result = await runTsgo(files, outDir, configDir);
+  if (result === null) {
+    result = await runTsc(files, outDir, configDir);
+  }
+  return result;
 }
 
-/**
- * Run tsgo CLI for declaration generation
- * Returns null if tsgo is not available
- */
+// ---------------------------------------------------------------------------
+// tsgo / tsc runners
+// ---------------------------------------------------------------------------
+
 async function runTsgo(
-  entryFile: string,
+  files: string[],
   outDir: string,
   cwd: string,
 ): Promise<DeclarationResult | null> {
-  return new Promise((resolve) => {
-    // Use npx to run tsgo from @typescript/native-preview
-    // --ignoreConfig to skip tsconfig.json when files are specified on command line
-    const command = `npx tsgo --declaration --emitDeclarationOnly --outDir "${outDir}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext --ignoreConfig "${entryFile}"`;
+  const fileArgs = files.map((f) => `"${f}"`).join(" ");
+  const command = `npx tsgo ${fileArgs} --declaration --emitDeclarationOnly --outDir "${outDir}" --rootDir "${cwd}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext --jsx react-jsx --ignoreConfig`;
 
+  return new Promise((resolve) => {
     const proc = spawn(command, { shell: true, cwd });
-
     let output = "";
     let errorOutput = "";
-
-    proc.stdout.on("data", (data) => {
+    proc.stdout.on("data", (data: Buffer) => {
       output += data.toString();
     });
-
-    proc.stderr.on("data", (data) => {
+    proc.stderr.on("data", (data: Buffer) => {
       errorOutput += data.toString();
     });
-
-    proc.on("error", () => {
-      // tsgo not available
-      resolve(null);
-    });
-
-    proc.on("close", (code) => {
-      // Check if tsgo was not found
+    proc.on("error", () => resolve(null));
+    proc.on("close", (code: number) => {
       if (
         errorOutput.includes("not found") ||
         errorOutput.includes("ENOENT") ||
@@ -245,64 +243,40 @@ async function runTsgo(
         resolve(null);
         return;
       }
-
-      const allOutput = output + errorOutput;
-      const errors = parseTypeScriptErrors(allOutput, cwd);
-
-      resolve({
-        success: code === 0 && errors.length === 0,
-        errors,
-      });
+      const errors = parseTypeScriptErrors(output + errorOutput, cwd);
+      resolve({ success: code === 0 && errors.length === 0, errors });
     });
   });
 }
 
-/**
- * Run tsc CLI for declaration generation (fallback)
- */
 async function runTsc(
-  entryFile: string,
+  files: string[],
   outDir: string,
   cwd: string,
 ): Promise<DeclarationResult> {
-  return new Promise((resolve) => {
-    const command = `npx tsc --declaration --emitDeclarationOnly --outDir "${outDir}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext "${entryFile}"`;
+  const fileArgs = files.map((f) => `"${f}"`).join(" ");
+  const command = `npx tsc ${fileArgs} --declaration --emitDeclarationOnly --outDir "${outDir}" --rootDir "${cwd}" --skipLibCheck --moduleResolution bundler --module esnext --target esnext --jsx react-jsx`;
 
+  return new Promise((resolve) => {
     const proc = spawn(command, { shell: true, cwd });
-
     let output = "";
     let errorOutput = "";
-
-    proc.stdout.on("data", (data) => {
+    proc.stdout.on("data", (data: Buffer) => {
       output += data.toString();
     });
-
-    proc.stderr.on("data", (data) => {
+    proc.stderr.on("data", (data: Buffer) => {
       errorOutput += data.toString();
     });
-
-    proc.on("close", (code) => {
-      const allOutput = output + errorOutput;
-      const errors = parseTypeScriptErrors(allOutput, cwd);
-
-      resolve({
-        success: code === 0 && errors.length === 0,
-        errors,
-      });
+    proc.on("close", (code: number) => {
+      const errors = parseTypeScriptErrors(output + errorOutput, cwd);
+      resolve({ success: code === 0 && errors.length === 0, errors });
     });
   });
 }
 
-/**
- * Parse TypeScript CLI error output into structured errors
- */
 function parseTypeScriptErrors(output: string, cwd: string): string[] {
   const errors: string[] = [];
-  const lines = output.split("\n");
-
-  for (const line of lines) {
-    // Match TypeScript error format: file(line,col): error TS1234: message
-    // or: file:line:col - error TS1234: message
+  for (const line of output.split("\n")) {
     const match = line.match(
       /^(.+?)(?:\((\d+),(\d+)\)|:(\d+):(\d+))\s*[-:]\s*error\s+TS\d+:\s*(.+)$/,
     );
@@ -310,33 +284,28 @@ function parseTypeScriptErrors(output: string, cwd: string): string[] {
       const file = match[1].replace(cwd + "/", "");
       const lineNum = match[2] || match[4];
       const col = match[3] || match[5];
-      const message = match[6];
-      errors.push(`${file}:${lineNum}:${col} - ${message}`);
+      errors.push(`${file}:${lineNum}:${col} - ${match[6]}`);
     } else if (line.includes("error TS")) {
-      // Catch any other error format
       errors.push(line.trim());
     }
   }
-
   return errors;
 }
 
-// Legacy functions for backward compatibility
+// Legacy
 export async function buildClient(
   configPath: string,
   config: ArcConfig,
   client: string,
-  watch: boolean = false,
+  watch = false,
 ): Promise<void> {
   const configDir = dirname(configPath);
-
   if (config.file) {
     const context: ContextInfo = {
       name: "main",
       entryFile: config.file,
       fullPath: join(configDir, config.file),
     };
-
     await buildContextBundle(configPath, config, context, client, watch);
   }
 }
@@ -347,14 +316,12 @@ export async function buildDeclarations(
   client: string,
 ): Promise<void> {
   const configDir = dirname(configPath);
-
   if (config.file) {
     const context: ContextInfo = {
       name: "main",
       entryFile: config.file,
       fullPath: join(configDir, config.file),
     };
-
     await buildContextDeclarations(configPath, config, context, client);
   }
 }

package/src/utils/config.ts

@@ -113,40 +113,29 @@ export function getContextsFromConfig(
 
 /**
  * Generate base types file for TypeScript intellisense
- * This creates a file with all constants defined as boolean type
+ * This creates a .d.ts file with all constants defined as boolean type
  */
 export function generateBaseTypes(config: ArcConfig, configDir: string): void {
   const { clients } = config;
 
-  // Create .arc directory if it doesn't exist
-  const arcDir = join(configDir, ".arc");
-  if (!existsSync(arcDir)) {
-    mkdirSync(arcDir, { recursive: true });
-  }
-
-  // Generate types.ts file with boolean declarations for IDE support
-  let typesDefs = `declare global {\n`;
+  // Generate ambient declarations (no export {} so they're truly global)
+  let typesDefs = "";
 
   clients.forEach((client) => {
     const normalizedClient = normalizeClientName(client);
 
-    typesDefs += `  const ${normalizedClient}: boolean;\n`;
-    typesDefs += `  const NOT_ON_${normalizedClient}: boolean;\n`;
-    typesDefs += `  const ONLY_${normalizedClient}: boolean;\n`;
+    typesDefs += `declare const ${normalizedClient}: boolean;\n`;
+    typesDefs += `declare const NOT_ON_${normalizedClient}: boolean;\n`;
+    typesDefs += `declare const ONLY_${normalizedClient}: boolean;\n`;
   });
 
-  typesDefs += `}\n\nexport {};\n`;
-
-  writeFileSync(join(arcDir, "types.ts"), typesDefs);
-
-  // Also generate arc.types.ts in root for backward compatibility
-  // Only generate at root level - contexts should reference the root file
-  writeFileSync(join(configDir, "arc.types.ts"), typesDefs);
+  // Write as .d.ts file in the config directory for proper TypeScript pickup
+  writeFileSync(join(configDir, "arc.d.ts"), typesDefs);
 }
 
 /**
  * Generate client-specific types file for a build
- * This creates a file with concrete true/false values based on the current client
+ * This creates a .d.ts file with concrete true/false values based on the current client
  */
 export function generateClientTypes(
   config: ArcConfig,
@@ -154,33 +143,31 @@ export function generateClientTypes(
   client: string,
 ): string {
   const { clients } = config;
-  const arcDir = join(configDir, ".arc");
 
-  // Create client-specific types directory
+  // Create .arc/client-types directory
+  const arcDir = join(configDir, ".arc");
   const clientTypesDir = join(arcDir, "client-types");
   if (!existsSync(clientTypesDir)) {
     mkdirSync(clientTypesDir, { recursive: true });
   }
 
-  // Generate client-specific types file
-  let typesDefs = `declare global {\n`;
+  // Generate client-specific ambient declarations
+  let typesDefs = "";
 
   clients.forEach((c) => {
     const normalizedC = normalizeClientName(c);
     const isCurrentClient = normalizeClientName(client) === normalizedC;
 
     // Set concrete values based on the current client
-    typesDefs += `  const ${normalizedC}: ${isCurrentClient ? "true" : "false"};\n`;
-    typesDefs += `  const NOT_ON_${normalizedC}: ${isCurrentClient ? "false" : "true"};\n`;
-    typesDefs += `  const ONLY_${normalizedC}: ${isCurrentClient ? "true" : "false"};\n`;
+    typesDefs += `declare const ${normalizedC}: ${isCurrentClient ? "true" : "false"};\n`;
+    typesDefs += `declare const NOT_ON_${normalizedC}: ${isCurrentClient ? "false" : "true"};\n`;
+    typesDefs += `declare const ONLY_${normalizedC}: ${isCurrentClient ? "true" : "false"};\n`;
   });
 
-  typesDefs += `}\n\nexport {};\n`;
-
-  // Write to a client-specific file
+  // Write as .d.ts file
   const typesPath = join(
     clientTypesDir,
-    `${normalizeClientName(client).toLowerCase()}.ts`,
+    `${normalizeClientName(client).toLowerCase()}.d.ts`,
   );
   writeFileSync(typesPath, typesDefs);