@arcote.tech/arc-cli 0.1.1

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@arcote.tech/arc-cli",
+  "version": "0.1.1",
+  "description": "CLI tool for Arc framework",
+  "module": "index.ts",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "arc": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "bun build --target=node ./src/index.ts --outdir=dist && chmod +x dist/index.js"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "chokidar": "^3.5.3",
+    "glob": "^10.3.10",
+    "find-up": "^7.0.0",
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^20.10.5",
+    "typescript": "^5.2.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/src/commands/build.ts

@@ -0,0 +1,68 @@
+import { findUpSync } from "find-up";
+import { dirname } from "path";
+import { buildClient, buildDeclarations } from "../utils/build";
+import {
+  findArcConfigs,
+  generateBaseTypes,
+  loadArcConfig,
+} from "../utils/config";
+
+export async function build(): Promise<void> {
+  try {
+    // Find the package.json from the current directory
+    const packageJsonPath = findUpSync("package.json", { cwd: process.cwd() });
+
+    if (!packageJsonPath) {
+      console.error("No package.json found");
+      process.exit(1);
+    }
+
+    const packageDir = dirname(packageJsonPath);
+    console.log(`Found package.json at: ${packageJsonPath}`);
+
+    // Find all arc.config.json files
+    const configPaths = await findArcConfigs(packageDir);
+    console.log(`Found ${configPaths.length} arc.config.json files`);
+
+    if (configPaths.length === 0) {
+      console.error("No arc.config.json files found");
+      process.exit(1);
+    }
+
+    // Process each config
+    for (const configPath of configPaths) {
+      console.log(`Processing config: ${configPath}`);
+
+      // Load the config
+      const config = await loadArcConfig(configPath);
+      const configDir = dirname(configPath);
+
+      // Generate base types file for IDE support
+      generateBaseTypes(config, configDir);
+      console.log(`Generated base types for IDE support`);
+
+      // Build each client
+      for (const client of config.clients) {
+        try {
+          // Build the client (without watch mode)
+          await buildClient(configPath, config, client, false);
+          console.log(`Built ${client} client successfully`);
+
+          // Build declarations
+          await buildDeclarations(configPath, config, client);
+          console.log(`Built declarations for ${client} successfully`);
+        } catch (err) {
+          console.error(
+            `Error building ${client}: ${err instanceof Error ? err.message : String(err)}`,
+          );
+          process.exit(1);
+        }
+      }
+    }
+
+    console.log("Build completed successfully.");
+  } catch (err) {
+    console.error("Error in build command:", err);
+    process.exit(1);
+  }
+}

package/src/commands/dev.ts

@@ -0,0 +1,112 @@
+import chokidar from "chokidar";
+import { findUpSync } from "find-up";
+import { dirname, join } from "path";
+import { buildClient, buildDeclarations } from "../utils/build";
+import {
+  findArcConfigs,
+  generateBaseTypes,
+  loadArcConfig,
+} from "../utils/config";
+
+export async function dev(): Promise<void> {
+  try {
+    // Find the package.json from the current directory
+    const packageJsonPath = findUpSync("package.json", { cwd: process.cwd() });
+
+    if (!packageJsonPath) {
+      console.error("No package.json found");
+      process.exit(1);
+    }
+
+    const packageDir = dirname(packageJsonPath);
+    console.log(`Found package.json at: ${packageJsonPath}`);
+
+    // Find all arc.config.json files
+    const configPaths = await findArcConfigs(packageDir);
+    console.log(`Found ${configPaths.length} arc.config.json files`);
+
+    if (configPaths.length === 0) {
+      console.error("No arc.config.json files found");
+      process.exit(1);
+    }
+
+    // Process each config
+    for (const configPath of configPaths) {
+      console.log(`Processing config: ${configPath}`);
+
+      // Load the config
+      const config = await loadArcConfig(configPath);
+      const configDir = dirname(configPath);
+
+      // Generate base types file for IDE support
+      generateBaseTypes(config, configDir);
+
+      console.log(`Generated base types for IDE support`);
+
+      // Set up source file watchers
+      const sourceWatcher = chokidar.watch(
+        [
+          join(configDir, "**/*.ts"),
+          join(configDir, "**/*.tsx"),
+          join(configDir, "**/*.js"),
+          join(configDir, "**/*.jsx"),
+        ],
+        {
+          ignored: [
+            "**/node_modules/**",
+            `**/${config.outDir}/**`, // Exclude the output directory
+            "**/.arc/client-types/**", // Exclude generated client types
+            "**/dist/**", // Exclude any dist directories
+            "**/*.d.ts", // Exclude declaration files
+          ],
+          persistent: true,
+        },
+      );
+
+      // Start watchers for each client
+      for (const client of config.clients) {
+        try {
+          // Start the client build in watch mode
+          buildClient(configPath, config, client, true).catch((err) =>
+            console.error(
+              `Error building ${client}: ${err instanceof Error ? err.message : String(err)}`,
+            ),
+          );
+          await buildDeclarations(configPath, config, client);
+
+          // Set up a handler for source file changes
+          sourceWatcher.on("change", async (path) => {
+            console.log(`Source file changed: ${path}`);
+
+            try {
+              // Build declarations when source files change
+              console.log(`Rebuilding declarations for ${client}...`);
+              await buildDeclarations(configPath, config, client);
+            } catch (err) {
+              console.error(
+                `Error building declarations for ${client}: ${err instanceof Error ? err.message : String(err)}`,
+              );
+            }
+          });
+        } catch (err) {
+          console.error(
+            `Error setting up build for ${client}: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+      }
+
+      console.log(`Watching for changes in ${configDir}...`);
+    }
+
+    console.log("Development mode started. Press Ctrl+C to stop.");
+
+    // Keep the process running
+    process.on("SIGINT", () => {
+      console.log("Shutting down dev mode...");
+      process.exit(0);
+    });
+  } catch (err) {
+    console.error("Error in dev command:", err);
+    process.exit(1);
+  }
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { build } from "./commands/build";
+import { dev } from "./commands/dev";
+
+// Create the program
+const program = new Command();
+
+// Setup program information
+program.name("arc").description("CLI tool for Arc framework").version("0.0.1");
+
+// Register commands
+program
+  .command("dev")
+  .description("Run development mode for Arc framework")
+  .action(dev);
+
+program
+  .command("build")
+  .description("Build all clients and declarations")
+  .action(build);
+
+// Parse command line arguments
+program.parse(process.argv);
+
+// If no arguments, show help
+if (process.argv.length === 2) {
+  program.help();
+}

package/src/utils/build.ts

@@ -0,0 +1,146 @@
+import { spawn } from "child_process";
+import { dirname, join } from "path";
+import * as ts from "typescript";
+import type { ArcConfig } from "./config";
+import { generateClientTypes } from "./config";
+
+/**
+ * Build a package using Bun for a specific client
+ */
+export async function buildClient(
+  configPath: string,
+  config: ArcConfig,
+  client: string,
+  watch: boolean = false,
+): Promise<void> {
+  const configDir = dirname(configPath);
+  const { file, outDir } = config;
+  const normalizedClient = client.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+
+  // Prepare the define values for this client
+  const defineValues: Record<string, string> = {};
+
+  // Set the current client to true and all others to false
+  for (const c of config.clients) {
+    const normalizedC = c.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+
+    // Set client flags
+    defineValues[normalizedC] = c === client ? "true" : "false";
+    defineValues[`NOT_ON_${normalizedC}`] = c === client ? "false" : "true";
+    defineValues[`ONLY_${normalizedC}`] = c === client ? "true" : "false";
+  }
+
+  // Create the define argument string
+  const defineArgs = Object.entries(defineValues)
+    .map(([key, value]) => `--define="${key}=${value}"`)
+    .join(" ");
+
+  // Construct the bun build command
+  const filePath = join(configDir, file);
+  const outFilePath = join(configDir, outDir, client.toLowerCase(), "index.js");
+
+  const command = `bun build ${filePath} --outfile=${outFilePath} ${defineArgs}${watch ? " --watch" : ""}`;
+
+  console.log(`Building ${client} client...`);
+  console.log(command);
+
+  return new Promise((resolve, reject) => {
+    const process = spawn(command, { shell: true, cwd: configDir });
+
+    process.stdout.on("data", (data) => {
+      console.log(`[${client}] ${data.toString().trim()}`);
+    });
+
+    process.stderr.on("data", (data) => {
+      console.error(`[${client} ERROR] ${data.toString().trim()}`);
+    });
+
+    process.on("close", (code) => {
+      if (code !== 0 && !watch) {
+        reject(new Error(`Build for ${client} failed with code ${code}`));
+      } else if (!watch) {
+        resolve();
+      }
+      // Don't resolve for watch mode, it keeps running
+    });
+  });
+}
+
+/**
+ * Build declarations using TypeScript Compiler API
+ */
+export async function buildDeclarations(
+  configPath: string,
+  config: ArcConfig,
+  client: string,
+): Promise<void> {
+  const configDir = dirname(configPath);
+  const { file } = config;
+  const filePath = join(configDir, file);
+
+  // Generate the client-specific types file and get its path
+  const clientTypesPath = generateClientTypes(config, configDir, client);
+
+  console.log(`Building ${client} declarations...`);
+
+  return new Promise((resolve, reject) => {
+    try {
+      // TypeScript compiler options for declaration files
+      const compilerOptions: ts.CompilerOptions = {
+        declaration: true,
+        emitDeclarationOnly: true,
+        outDir: join(configDir, config.outDir, client.toLowerCase()),
+      };
+
+      // Create the program with the client-specific types
+      const program = ts.createProgram(
+        [filePath, clientTypesPath],
+        compilerOptions,
+      );
+
+      // Emit the declarations
+      const emitResult = program.emit();
+
+      // Report any errors
+      const diagnostics = ts
+        .getPreEmitDiagnostics(program)
+        .concat(emitResult.diagnostics);
+
+      if (diagnostics.length > 0) {
+        let errorMessage = "";
+        diagnostics.forEach((diagnostic) => {
+          if (diagnostic.file) {
+            const { line, character } = ts.getLineAndCharacterOfPosition(
+              diagnostic.file,
+              diagnostic.start!,
+            );
+            const message = ts.flattenDiagnosticMessageText(
+              diagnostic.messageText,
+              "\n",
+            );
+            errorMessage += `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}\n`;
+          } else {
+            errorMessage += `${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}\n`;
+          }
+        });
+
+        if (emitResult.emitSkipped) {
+          reject(
+            new Error(
+              `Declaration build for ${client} failed:\n${errorMessage}`,
+            ),
+          );
+        } else {
+          // console.warn(
+          //   `Declaration build for ${client} had warnings:\n${errorMessage}`,
+          // );
+          resolve();
+        }
+      } else {
+        resolve();
+      }
+    } catch (err) {
+      reject(err instanceof Error ? err : new Error(String(err)));
+    }
+  });
+}

package/src/utils/config.ts

@@ -0,0 +1,141 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { glob } from "glob";
+import { join } from "path";
+
+export interface ArcConfig {
+  file: string;
+  outDir: string;
+  clients: string[];
+}
+
+/**
+ * Find arc.config.json files in the workspace
+ */
+export async function findArcConfigs(packagePath: string): Promise<string[]> {
+  // Check if we're in a monorepo
+  const packageJson = JSON.parse(
+    readFileSync(join(packagePath, "package.json"), "utf-8"),
+  );
+
+  // If workspaces field exists, we're in a monorepo
+  if (packageJson.workspaces) {
+    const workspacePatterns = Array.isArray(packageJson.workspaces)
+      ? packageJson.workspaces
+      : packageJson.workspaces.packages || [];
+
+    // Get all directory paths from workspace patterns
+    const workspaceDirs = await glob(workspacePatterns, {
+      cwd: packagePath,
+      absolute: true,
+    });
+
+    // Find all arc.config.json files in workspace directories
+    const configFiles: string[] = [];
+
+    for (const dir of workspaceDirs) {
+      const configsInDir = await glob("**/arc.config.json", {
+        cwd: dir,
+        absolute: true,
+      });
+
+      configFiles.push(...configsInDir);
+    }
+
+    return configFiles;
+  } else {
+    // Not a monorepo, just find arc.config.json files in the package
+    return await glob("**/arc.config.json", {
+      cwd: packagePath,
+      absolute: true,
+    });
+  }
+}
+
+/**
+ * Load and parse an arc.config.json file
+ */
+export async function loadArcConfig(configPath: string): Promise<ArcConfig> {
+  // Read and parse the JSON config file
+  const configContent = readFileSync(configPath, "utf-8");
+  const config: ArcConfig = JSON.parse(configContent);
+  return config;
+}
+
+/**
+ * Generate base types file for TypeScript intellisense
+ * This creates a 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`;
+
+  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 += `}\n\nexport {};\n`;
+
+  writeFileSync(join(arcDir, "types.ts"), typesDefs);
+}
+
+/**
+ * Generate client-specific types file for a build
+ * This creates a file with concrete true/false values based on the current client
+ */
+export function generateClientTypes(
+  config: ArcConfig,
+  configDir: string,
+  client: string,
+): string {
+  const { clients } = config;
+  const arcDir = join(configDir, ".arc");
+
+  // Create client-specific types directory
+  const clientTypesDir = join(arcDir, "client-types");
+  if (!existsSync(clientTypesDir)) {
+    mkdirSync(clientTypesDir, { recursive: true });
+  }
+
+  // Generate client-specific types file
+  let typesDefs = `declare global {\n`;
+
+  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 += `}\n\nexport {};\n`;
+
+  // Write to a client-specific file
+  const typesPath = join(
+    clientTypesDir,
+    `${normalizeClientName(client).toLowerCase()}.ts`,
+  );
+  writeFileSync(typesPath, typesDefs);
+
+  return typesPath;
+}
+
+/**
+ * Normalize client name to a valid identifier
+ */
+export function normalizeClientName(client: string): string {
+  return client.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "noEmit": false
+  },
+  "include": ["src/**/*.ts"]
+}