zephyr-cli 0.0.3 → 0.1.3-next.7

package/src/index.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { cwd } from 'node:process';
+import { ZeErrors, ZephyrError } from 'zephyr-agent';
+import { parseArgs } from './cli';
+import { deployCommand } from './commands/deploy';
+import { runCommand } from './commands/run';
+
+async function main(): Promise<void> {
+  try {
+    // Parse command line arguments
+    const args = process.argv.slice(2);
+    const options = parseArgs(args);
+
+    // Get current working directory
+    const workingDir = cwd();
+
+    // Dispatch to the appropriate command
+    if (options.command === 'deploy') {
+      if (!options.directory) {
+        throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+          message: 'Directory is required for deploy command',
+        });
+      }
+
+      await deployCommand({
+        directory: options.directory,
+        target: options.target,
+        verbose: options.verbose,
+        ssr: options.ssr,
+        cwd: workingDir,
+      });
+    } else if (options.command === 'run') {
+      if (!options.commandLine) {
+        throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+          message: 'Command line is required for run command',
+        });
+      }
+
+      await runCommand({
+        commandLine: options.commandLine,
+        target: options.target,
+        verbose: options.verbose,
+        ssr: options.ssr,
+        cwd: workingDir,
+      });
+    }
+  } catch (error) {
+    console.error('[ze-cli] Error:', ZephyrError.format(error));
+    process.exit(1);
+  }
+}
+
+// Run the CLI
+main().catch((error) => {
+  console.error('[ze-cli] Fatal error:', ZephyrError.format(error));
+  process.exit(1);
+});

package/src/lib/build-stats.ts

@@ -0,0 +1,13 @@
+import type { ZephyrBuildStats } from 'zephyr-edge-contract';
+import type { ZephyrEngine } from 'zephyr-agent';
+import { zeBuildDashData } from 'zephyr-agent';
+
+/**
+ * Generate build stats from ZephyrEngine. This is a simple wrapper around zeBuildDashData
+ * for consistency.
+ */
+export async function getBuildStats(
+  zephyr_engine: ZephyrEngine
+): Promise<ZephyrBuildStats> {
+  return await zeBuildDashData(zephyr_engine);
+}

package/src/lib/command-detector.ts

@@ -0,0 +1,600 @@
+import { existsSync } from 'node:fs';
+import { join, resolve, relative, sep } from 'node:path';
+import {
+  configFileExists,
+  isJavaScriptConfig,
+  readPackageJson,
+  readTsConfig,
+  loadWebpackConfig,
+  loadViteConfig,
+  loadRollupConfig,
+  loadSwcConfig,
+} from './config-readers';
+import type { ParsedCommand } from './shell-parser';
+import { parseShellCommand, splitCommands } from './shell-parser';
+
+export interface DetectedCommand {
+  /** The build tool detected (e.g., 'tsc', 'webpack', 'npm') */
+  tool: string;
+  /** The configuration file path, if detected */
+  configFile: string | null;
+  /** Whether the config file is JavaScript (dynamic config) */
+  isDynamicConfig: boolean;
+  /** The inferred output directory, if detectable */
+  outputDir: string | null;
+  /** Warnings to display to the user */
+  warnings: string[];
+  /**
+   * Sub-commands detected when a command expands to multiple commands (e.g., npm script
+   * with &&)
+   */
+  subCommands?: DetectedCommand[];
+}
+
+/**
+ * Find the value of a command-line argument, supporting both formats:
+ *
+ * - `--flag value` (space-separated)
+ * - `--flag=value` (equals-separated)
+ * - `-f value` (short flag with space)
+ * - `-f=value` (short flag with equals)
+ */
+function findArgValue(args: string[], ...flags: string[]): string | null {
+  for (const flag of flags) {
+    // Look for space-separated format: --flag value
+    const index = args.indexOf(flag);
+    if (index !== -1 && index + 1 < args.length) {
+      return args[index + 1];
+    }
+
+    // Look for equals format: --flag=value
+    const prefix = `${flag}=`;
+    for (const arg of args) {
+      if (arg.startsWith(prefix)) {
+        return arg.substring(prefix.length);
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Find the common ancestor directory of multiple paths, bounded by the project root.
+ *
+ * @param paths - Array of absolute paths
+ * @param projectRoot - The project root directory (boundary)
+ * @returns The common ancestor path, or null if paths are empty or no common ancestor
+ *   within project root
+ */
+export function findCommonAncestor(paths: string[], projectRoot: string): string | null {
+  if (paths.length === 0) {
+    return null;
+  }
+
+  if (paths.length === 1) {
+    return paths[0];
+  }
+
+  // Normalize all paths to absolute
+  const normalizedPaths = paths.map((p) => resolve(p));
+  const normalizedRoot = resolve(projectRoot);
+
+  // Split each path into segments
+  const pathSegments = normalizedPaths.map((p) => p.split(sep));
+  const rootSegments = normalizedRoot.split(sep);
+
+  // Find the common prefix across all paths
+  const commonSegments: string[] = [];
+  const minLength = Math.min(...pathSegments.map((p) => p.length));
+
+  for (let i = 0; i < minLength; i++) {
+    const segment = pathSegments[0][i];
+
+    // Check if all paths have the same segment at this position
+    if (pathSegments.every((p) => p[i] === segment)) {
+      commonSegments.push(segment);
+    } else {
+      break;
+    }
+  }
+
+  // Ensure the common ancestor is within or equal to the project root
+  const commonPath = commonSegments.join(sep) || sep;
+
+  // Check if common path is within project root
+  const relativeToRoot = relative(normalizedRoot, commonPath);
+
+  // If relative path starts with '..' or is absolute, it's outside project root
+  if (relativeToRoot.startsWith('..') || resolve(commonPath) !== commonPath) {
+    return normalizedRoot;
+  }
+
+  // If common path is shallower than project root, use project root
+  if (commonSegments.length < rootSegments.length) {
+    return normalizedRoot;
+  }
+
+  return commonPath;
+}
+
+/**
+ * Detect multiple commands from a command line that may contain shell operators (;, &&).
+ * Returns output directories from all detected commands.
+ */
+export async function detectMultipleCommands(
+  commandLine: string,
+  cwd: string
+): Promise<{
+  commands: DetectedCommand[];
+  outputDirs: string[];
+  commonOutputDir: string | null;
+}> {
+  const individualCommands = splitCommands(commandLine);
+  const detectedCommands: DetectedCommand[] = [];
+  const outputDirs: string[] = [];
+
+  for (const cmd of individualCommands) {
+    try {
+      const parsed = parseShellCommand(cmd);
+      const detected = await detectCommand(parsed, cwd);
+      detectedCommands.push(detected);
+
+      if (detected.outputDir) {
+        const absoluteOutputDir = resolve(cwd, detected.outputDir);
+        outputDirs.push(absoluteOutputDir);
+      }
+    } catch {
+      // Skip commands that fail to parse
+      console.error(`[ze-cli] Warning: Failed to parse command: ${cmd}`);
+    }
+  }
+
+  // Find common ancestor of all output directories
+  const commonOutputDir =
+    outputDirs.length > 0 ? findCommonAncestor(outputDirs, cwd) : null;
+
+  return {
+    commands: detectedCommands,
+    outputDirs,
+    commonOutputDir,
+  };
+}
+
+/** Detect the build tool and its configuration from a parsed command */
+export async function detectCommand(
+  parsed: ParsedCommand,
+  cwd: string,
+  depth = 0
+): Promise<DetectedCommand> {
+  const { command, args } = parsed;
+  const warnings: string[] = [];
+
+  // Prevent infinite recursion
+  if (depth > 3) {
+    warnings.push('Max recursion depth reached while parsing scripts');
+    return {
+      tool: command,
+      configFile: null,
+      isDynamicConfig: false,
+      outputDir: null,
+      warnings,
+    };
+  }
+
+  // Detect npm/yarn/pnpm commands
+  if (['npm', 'yarn', 'pnpm'].includes(command)) {
+    return await detectPackageManagerCommand(command, args, cwd, warnings, depth);
+  }
+
+  // Detect tsc (TypeScript compiler)
+  if (command === 'tsc') {
+    return detectTscCommand(args, cwd, warnings);
+  }
+
+  // Detect webpack
+  if (command === 'webpack' || command === 'webpack-cli') {
+    return await detectWebpackCommand(cwd, warnings);
+  }
+
+  // Detect rollup
+  if (command === 'rollup') {
+    return await detectRollupCommand(cwd, warnings);
+  }
+
+  // Detect esbuild
+  if (command === 'esbuild') {
+    return detectEsbuildCommand(args, warnings);
+  }
+
+  // Detect vite
+  if (command === 'vite') {
+    return await detectViteCommand(cwd, warnings);
+  }
+
+  // Detect swc
+  if (command === 'swc') {
+    return await detectSwcCommand(cwd, warnings);
+  }
+
+  // Unknown command
+  return {
+    tool: command,
+    configFile: null,
+    isDynamicConfig: false,
+    outputDir: null,
+    warnings: [
+      `Unknown build tool: ${command}`,
+      'Output directory detection may not work correctly.',
+    ],
+  };
+}
+
+async function detectPackageManagerCommand(
+  command: string,
+  args: string[],
+  cwd: string,
+  warnings: string[],
+  depth: number
+): Promise<DetectedCommand> {
+  const packageJson = readPackageJson(cwd);
+
+  if (!packageJson) {
+    warnings.push('package.json not found');
+    return {
+      tool: command,
+      configFile: null,
+      isDynamicConfig: false,
+      outputDir: null,
+      warnings,
+    };
+  }
+
+  // Find the script name
+  let scriptName: string | null = null;
+  if (command === 'npm' && args[0] === 'run' && args[1]) {
+    scriptName = args[1];
+  } else if ((command === 'yarn' || command === 'pnpm') && args[0]) {
+    scriptName = args[0];
+  }
+
+  if (!scriptName || !packageJson.scripts?.[scriptName]) {
+    warnings.push(`Script "${scriptName || 'unknown'}" not found in package.json`);
+    return {
+      tool: command,
+      configFile: join(cwd, 'package.json'),
+      isDynamicConfig: false,
+      outputDir: null,
+      warnings,
+    };
+  }
+
+  const script = packageJson.scripts[scriptName];
+
+  // Parse the script command - check if there are multiple commands with shell operators
+  try {
+    const individualCommands = splitCommands(script);
+
+    // If there are multiple commands in the script, detect each one
+    if (individualCommands.length > 1) {
+      const detectedCommands: DetectedCommand[] = [];
+      const allWarnings: string[] = [...warnings];
+      const outputDirs: string[] = [];
+
+      for (const cmd of individualCommands) {
+        try {
+          const parsedScript = parseShellCommand(cmd);
+          const detected = await detectCommand(parsedScript, cwd, depth + 1);
+          detectedCommands.push(detected);
+
+          if (detected.outputDir) {
+            outputDirs.push(resolve(cwd, detected.outputDir));
+          }
+
+          allWarnings.push(...detected.warnings);
+        } catch {
+          // Skip commands that fail to parse
+          allWarnings.push(`Failed to parse sub-command: ${cmd}`);
+        }
+      }
+
+      // Find the last command that produces output
+      let primaryDetected =
+        detectedCommands.find((d) => d.outputDir) ||
+        detectedCommands[detectedCommands.length - 1];
+
+      // If multiple output directories, use common ancestor
+      if (outputDirs.length > 1) {
+        const commonOutputDir = findCommonAncestor(outputDirs, cwd);
+        if (commonOutputDir) {
+          primaryDetected = {
+            ...primaryDetected,
+            outputDir: relative(cwd, commonOutputDir) || '.',
+          };
+        }
+      } else if (outputDirs.length === 1) {
+        primaryDetected = {
+          ...primaryDetected,
+          outputDir: relative(cwd, outputDirs[0]) || '.',
+        };
+      }
+
+      // Preserve the package.json reference
+      if (!primaryDetected.configFile) {
+        primaryDetected.configFile = join(cwd, 'package.json');
+      }
+
+      primaryDetected.warnings = allWarnings;
+      // Store sub-commands for logging purposes
+      primaryDetected.subCommands = detectedCommands;
+      return primaryDetected;
+    }
+
+    // Single command - parse normally
+    const parsedScript = parseShellCommand(script);
+
+    // Recursively detect the actual build tool
+    const detected = await detectCommand(parsedScript, cwd, depth + 1);
+
+    // Preserve the package.json reference
+    if (!detected.configFile) {
+      detected.configFile = join(cwd, 'package.json');
+    }
+
+    return detected;
+  } catch (error) {
+    warnings.push(`Failed to parse package.json script "${scriptName}": ${script}`);
+    warnings.push(`Parse error: ${(error as Error).message}`);
+
+    return {
+      tool: command,
+      configFile: join(cwd, 'package.json'),
+      isDynamicConfig: false,
+      outputDir: null,
+      warnings,
+    };
+  }
+}
+
+function detectTscCommand(
+  args: string[],
+  cwd: string,
+  warnings: string[]
+): DetectedCommand {
+  // Look for -p or --project flag
+  const configPath = findArgValue(args, '-p', '--project') || 'tsconfig.json';
+
+  const fullConfigPath = join(cwd, configPath);
+  const configExists = existsSync(fullConfigPath);
+
+  if (!configExists) {
+    warnings.push(`TypeScript config not found: ${configPath}`);
+    return {
+      tool: 'tsc',
+      configFile: null,
+      isDynamicConfig: false,
+      outputDir: null,
+      warnings,
+    };
+  }
+
+  // Try to read outDir from tsconfig
+  const tsConfig = readTsConfig(cwd, configPath);
+  const outDir = tsConfig?.compilerOptions?.outDir || null;
+
+  return {
+    tool: 'tsc',
+    configFile: fullConfigPath,
+    isDynamicConfig: false,
+    outputDir: outDir,
+    warnings,
+  };
+}
+
+async function detectWebpackCommand(
+  cwd: string,
+  warnings: string[]
+): Promise<DetectedCommand> {
+  const configFile = configFileExists(cwd, 'webpack.config');
+  const isDynamicConfig = isJavaScriptConfig(cwd, 'webpack.config');
+
+  // Try to load the config using cosmiconfig if it's a JS config
+  if (isDynamicConfig) {
+    try {
+      const loadedConfig = await loadWebpackConfig(cwd);
+
+      if (loadedConfig && loadedConfig.outputDir) {
+        // Successfully loaded and extracted output directory
+        return {
+          tool: 'webpack',
+          configFile: loadedConfig.filepath,
+          isDynamicConfig: true,
+          outputDir: loadedConfig.outputDir,
+          warnings,
+        };
+      }
+
+      // Config loaded but couldn't extract output directory
+      warnings.push(
+        'Webpack configuration loaded but output directory could not be determined.',
+        'Consider using @zephyrcloud/webpack-plugin or ze-cli deploy after building.'
+      );
+    } catch {
+      warnings.push(
+        'Failed to load Webpack configuration.',
+        'Consider using @zephyrcloud/webpack-plugin or ze-cli deploy after building.'
+      );
+    }
+  }
+
+  return {
+    tool: 'webpack',
+    configFile,
+    isDynamicConfig,
+    outputDir: isDynamicConfig ? null : 'dist',
+    warnings,
+  };
+}
+
+async function detectRollupCommand(
+  cwd: string,
+  warnings: string[]
+): Promise<DetectedCommand> {
+  const configFile = configFileExists(cwd, 'rollup.config');
+  const isDynamicConfig = isJavaScriptConfig(cwd, 'rollup.config');
+
+  // Try to load the config using cosmiconfig if it's a JS config
+  if (isDynamicConfig) {
+    try {
+      const loadedConfig = await loadRollupConfig(cwd);
+
+      if (loadedConfig && loadedConfig.outputDir) {
+        // Successfully loaded and extracted output directory
+        return {
+          tool: 'rollup',
+          configFile: loadedConfig.filepath,
+          isDynamicConfig: true,
+          outputDir: loadedConfig.outputDir,
+          warnings,
+        };
+      }
+
+      // Config loaded but couldn't extract output directory
+      warnings.push(
+        'Rollup configuration loaded but output directory could not be determined.',
+        'Consider using @zephyrcloud/rollup-plugin or ze-cli deploy after building.'
+      );
+    } catch {
+      warnings.push(
+        'Failed to load Rollup configuration.',
+        'Consider using @zephyrcloud/rollup-plugin or ze-cli deploy after building.'
+      );
+    }
+  }
+
+  return {
+    tool: 'rollup',
+    configFile,
+    isDynamicConfig,
+    outputDir: isDynamicConfig ? null : 'dist',
+    warnings,
+  };
+}
+
+function detectEsbuildCommand(args: string[], warnings: string[]): DetectedCommand {
+  // Look for --outdir or --outfile in args
+  let outputDir: string | null = null;
+
+  const outdir = findArgValue(args, '--outdir');
+  const outfile = findArgValue(args, '--outfile');
+
+  if (outdir) {
+    outputDir = outdir;
+  } else if (outfile) {
+    // Extract directory from outfile
+    const lastSlash = Math.max(outfile.lastIndexOf('/'), outfile.lastIndexOf('\\'));
+    outputDir = lastSlash !== -1 ? outfile.substring(0, lastSlash) : '.';
+  }
+
+  if (!outputDir) {
+    warnings.push('Could not detect esbuild output directory from arguments');
+  }
+
+  return {
+    tool: 'esbuild',
+    configFile: null,
+    isDynamicConfig: false,
+    outputDir,
+    warnings,
+  };
+}
+
+async function detectViteCommand(
+  cwd: string,
+  warnings: string[]
+): Promise<DetectedCommand> {
+  const configFile = configFileExists(cwd, 'vite.config');
+  const isDynamicConfig = isJavaScriptConfig(cwd, 'vite.config');
+
+  // Try to load the config using cosmiconfig if it's a JS config
+  if (isDynamicConfig) {
+    try {
+      const loadedConfig = await loadViteConfig(cwd);
+
+      if (loadedConfig && loadedConfig.outputDir) {
+        // Successfully loaded and extracted output directory
+        return {
+          tool: 'vite',
+          configFile: loadedConfig.filepath,
+          isDynamicConfig: true,
+          outputDir: loadedConfig.outputDir,
+          warnings,
+        };
+      }
+
+      // Config loaded but couldn't extract output directory (fallback to default)
+      if (loadedConfig) {
+        return {
+          tool: 'vite',
+          configFile: loadedConfig.filepath,
+          isDynamicConfig: true,
+          outputDir: 'dist', // Vite default
+          warnings,
+        };
+      }
+
+      warnings.push(
+        'Failed to load Vite configuration.',
+        'Consider using @zephyrcloud/vite-plugin or ze-cli deploy after building.'
+      );
+    } catch {
+      warnings.push(
+        'Failed to load Vite configuration.',
+        'Consider using @zephyrcloud/vite-plugin or ze-cli deploy after building.'
+      );
+    }
+  }
+
+  return {
+    tool: 'vite',
+    configFile,
+    isDynamicConfig,
+    outputDir: isDynamicConfig ? null : 'dist',
+    warnings,
+  };
+}
+
+async function detectSwcCommand(
+  cwd: string,
+  warnings: string[]
+): Promise<DetectedCommand> {
+  const configFile = configFileExists(cwd, '.swcrc');
+  const isDynamicConfig = isJavaScriptConfig(cwd, '.swcrc');
+
+  // Try to load the config using cosmiconfig if it's a JS config
+  if (isDynamicConfig) {
+    try {
+      const loadedConfig = await loadSwcConfig(cwd);
+
+      if (loadedConfig) {
+        return {
+          tool: 'swc',
+          configFile: loadedConfig.filepath,
+          isDynamicConfig: true,
+          outputDir: 'dist', // SWC doesn't have standard output config
+          warnings,
+        };
+      }
+    } catch {
+      warnings.push('Failed to load SWC configuration.');
+    }
+  }
+
+  return {
+    tool: 'swc',
+    configFile,
+    isDynamicConfig,
+    outputDir: 'dist', // Common default
+    warnings,
+  };
+}