@diamondslab/diamonds-hardhat-foundry 1.0.0

package/src/types/config.ts

@@ -0,0 +1,54 @@
+/**
+ * Configuration types for diamonds-hardhat-foundry plugin
+ * Will be fully implemented in Task 2.1
+ */
+
+export interface DiamondsFoundryConfig {
+  /**
+   * Output directory for generated helpers (relative to project root)
+   * @default "test/foundry/helpers"
+   */
+  helpersDir?: string;
+
+  /**
+   * Whether to generate example tests on init
+   * @default true
+   */
+  generateExamples?: boolean;
+
+  /**
+   * Example test templates to generate
+   * @default ["unit", "integration", "fuzz"]
+   */
+  exampleTests?: Array<"unit" | "integration" | "fuzz">;
+
+  /**
+   * Default network for deployments
+   * @default "hardhat"
+   */
+  defaultNetwork?: string;
+
+  /**
+   * Whether to reuse existing deployment or deploy fresh
+   * @default true
+   */
+  reuseDeployment?: boolean;
+
+  /**
+   * Additional forge test arguments
+   * @default []
+   */
+  forgeTestArgs?: string[];
+}
+
+/**
+ * Default configuration values
+ */
+export const DEFAULT_CONFIG: Required<DiamondsFoundryConfig> = {
+  helpersDir: "test/foundry/helpers",
+  generateExamples: true,
+  exampleTests: ["unit", "integration", "fuzz"],
+  defaultNetwork: "hardhat",
+  reuseDeployment: true,
+  forgeTestArgs: [],
+};

package/src/types/hardhat.ts

@@ -0,0 +1,24 @@
+/**
+ * Type extensions for Hardhat Runtime Environment
+ */
+
+import "hardhat/types/config";
+import "hardhat/types/runtime";
+import { DiamondsFoundryConfig } from "../types/config";
+
+declare module "hardhat/types/config" {
+  export interface HardhatUserConfig {
+    diamondsFoundry?: Partial<DiamondsFoundryConfig>;
+  }
+
+  export interface HardhatConfig {
+    diamondsFoundry: Required<DiamondsFoundryConfig>;
+  }
+}
+
+declare module "hardhat/types/runtime" {
+  export interface HardhatRuntimeEnvironment {
+    diamondsFoundry: Required<DiamondsFoundryConfig>;
+    ethers: any; // Will be provided by @nomicfoundation/hardhat-ethers
+  }
+}

package/src/utils/foundry.ts

@@ -0,0 +1,189 @@
+import { execSync, spawn } from "child_process";
+import { Logger } from "./logger";
+
+/**
+ * Execute a Foundry command synchronously
+ * @param command - The foundry command (e.g., "forge test")
+ * @param args - Command arguments
+ * @param options - Execution options
+ */
+export function execForgeSync(
+  command: string,
+  args: string[] = [],
+  options: { cwd?: string; stdio?: "inherit" | "pipe" } = {}
+): string {
+  const fullCommand = `${command} ${args.join(" ")}`;
+  Logger.step(`Running: ${fullCommand}`);
+
+  try {
+    const output = execSync(fullCommand, {
+      cwd: options.cwd || process.cwd(),
+      stdio: options.stdio || "pipe",
+      encoding: "utf-8",
+    });
+
+    return output;
+  } catch (error: any) {
+    Logger.error(`Forge command failed: ${error.message}`);
+    if (error.stdout) Logger.info(error.stdout);
+    if (error.stderr) Logger.error(error.stderr);
+    throw error;
+  }
+}
+
+/**
+ * Execute a Foundry command asynchronously
+ * @param command - The foundry command (e.g., "forge")
+ * @param args - Command arguments
+ * @param options - Execution options
+ */
+export async function execForgeAsync(
+  command: string,
+  args: string[] = [],
+  options: { cwd?: string; verbose?: boolean } = {}
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  Logger.step(`Running: ${command} ${args.join(" ")}`);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd || process.cwd(),
+      shell: true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout?.on("data", (data) => {
+      const text = data.toString();
+      stdout += text;
+      if (options.verbose) {
+        process.stdout.write(text);
+      }
+    });
+
+    child.stderr?.on("data", (data) => {
+      const text = data.toString();
+      stderr += text;
+      if (options.verbose) {
+        process.stderr.write(text);
+      }
+    });
+
+    child.on("close", (code) => {
+      resolve({ stdout, stderr, exitCode: code || 0 });
+    });
+
+    child.on("error", (error) => {
+      Logger.error(`Failed to spawn ${command}: ${error.message}`);
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Run forge test with specified options
+ * @param options - Test execution options
+ */
+export async function runForgeTest(options: {
+  matchTest?: string;
+  matchContract?: string;
+  verbosity?: number;
+  gasReport?: boolean;
+  cwd?: string;
+  env?: Record<string, string>;
+}): Promise<{ success: boolean; output: string }> {
+  const args: string[] = ["test"];
+
+  if (options.matchTest) {
+    args.push("--match-test", options.matchTest);
+  }
+
+  if (options.matchContract) {
+    args.push("--match-contract", options.matchContract);
+  }
+
+  if (options.verbosity) {
+    args.push("-" + "v".repeat(options.verbosity));
+  }
+
+  if (options.gasReport) {
+    args.push("--gas-report");
+  }
+
+  try {
+    const result = await execForgeAsync("forge", args, {
+      cwd: options.cwd,
+      verbose: true,
+    });
+
+    const success = result.exitCode === 0;
+    
+    if (success) {
+      Logger.success("Forge tests passed!");
+    } else {
+      Logger.error("Forge tests failed");
+    }
+
+    return { success, output: result.stdout + result.stderr };
+  } catch (error: any) {
+    Logger.error(`Test execution failed: ${error.message}`);
+    return { success: false, output: error.message };
+  }
+}
+
+/**
+ * Compile Forge contracts
+ * @param options - Compilation options
+ */
+export async function compileForge(options: {
+  cwd?: string;
+  verbose?: boolean;
+}): Promise<{ success: boolean; output: string }> {
+  Logger.step("Compiling Forge contracts...");
+
+  try {
+    const result = await execForgeAsync("forge", ["build"], {
+      cwd: options.cwd,
+      verbose: options.verbose,
+    });
+
+    const success = result.exitCode === 0;
+    
+    if (success) {
+      Logger.success("Forge compilation successful!");
+    } else {
+      Logger.error("Forge compilation failed");
+    }
+
+    return { success, output: result.stdout + result.stderr };
+  } catch (error: any) {
+    Logger.error(`Compilation failed: ${error.message}`);
+    return { success: false, output: error.message };
+  }
+}
+
+/**
+ * Check if Foundry is installed
+ */
+export function isFoundryInstalled(): boolean {
+  try {
+    execSync("forge --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get Foundry version
+ */
+export function getFoundryVersion(): string | null {
+  try {
+    const output = execSync("forge --version", { encoding: "utf-8", stdio: "pipe" });
+    // Extract version from output like "forge 0.2.0 (abc123 2024-01-01T00:00:00.000000000Z)"
+    const match = output.match(/forge\s+([\d.]+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,66 @@
+import picocolors from "picocolors";
+
+/**
+ * Logger utility for colored console output
+ */
+export class Logger {
+  /**
+   * Log an info message in cyan
+   */
+  static info(message: string): void {
+    console.log(picocolors.cyan(`ℹ ${message}`));
+  }
+
+  /**
+   * Log a success message in green
+   */
+  static success(message: string): void {
+    console.log(picocolors.green(`✓ ${message}`));
+  }
+
+  /**
+   * Log a warning message in yellow
+   */
+  static warn(message: string): void {
+    console.log(picocolors.yellow(`⚠ ${message}`));
+  }
+
+  /**
+   * Log an error message in red
+   */
+  static error(message: string): void {
+    console.log(picocolors.red(`✗ ${message}`));
+  }
+
+  /**
+   * Log a step message in blue
+   */
+  static step(message: string): void {
+    console.log(picocolors.blue(`→ ${message}`));
+  }
+
+  /**
+   * Log a verbose/debug message in gray
+   */
+  static debug(message: string): void {
+    console.log(picocolors.gray(`  ${message}`));
+  }
+
+  /**
+   * Log a highlighted message in magenta
+   */
+  static highlight(message: string): void {
+    console.log(picocolors.magenta(`★ ${message}`));
+  }
+
+  /**
+   * Create a formatted section header
+   */
+  static section(title: string): void {
+    console.log("");
+    console.log(picocolors.bold(picocolors.cyan(`${"=".repeat(60)}`)));
+    console.log(picocolors.bold(picocolors.cyan(`  ${title}`)));
+    console.log(picocolors.bold(picocolors.cyan(`${"=".repeat(60)}`)));
+    console.log("");
+  }
+}

package/src/utils/validation.ts

@@ -0,0 +1,144 @@
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { DEFAULT_CONFIG, DiamondsFoundryConfig } from "../types/config";
+import { Logger } from "./logger";
+
+/**
+ * Validation utilities for diamonds-hardhat-foundry plugin
+ */
+
+/**
+ * Check if Foundry is installed
+ */
+export function validateFoundryInstallation(): boolean {
+  try {
+    execSync("forge --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if Foundry is installed and throw error if not
+ */
+export function requireFoundry(): void {
+  if (!validateFoundryInstallation()) {
+    Logger.error("Foundry is not installed or not in PATH");
+    Logger.info("Install Foundry from: https://getfoundry.sh/");
+    throw new Error("Foundry is required but not found");
+  }
+}
+
+/**
+ * Check if a peer dependency is installed
+ */
+export function validatePeerDependency(packageName: string): boolean {
+  try {
+    require.resolve(packageName);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if required peer dependencies are installed
+ */
+export function validatePeerDependencies(): void {
+  const requiredDeps = [
+    "@diamondslab/diamonds",
+    "@diamondslab/hardhat-diamonds",
+  ];
+
+  const missing: string[] = [];
+
+  for (const dep of requiredDeps) {
+    if (!validatePeerDependency(dep)) {
+      missing.push(dep);
+    }
+  }
+
+  if (missing.length > 0) {
+    Logger.error("Missing required peer dependencies:");
+    missing.forEach((dep) => Logger.error(`  - ${dep}`));
+    Logger.info("\nInstall them with:");
+    Logger.info(`  npm install ${missing.join(" ")}`);
+    throw new Error("Missing peer dependencies");
+  }
+}
+
+/**
+ * Validate and merge user config with defaults
+ */
+export function validateConfig(
+  userConfig?: Partial<DiamondsFoundryConfig>
+): Required<DiamondsFoundryConfig> {
+  const config: Required<DiamondsFoundryConfig> = {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+  };
+
+  // Validate helpersDir is a string
+  if (typeof config.helpersDir !== "string") {
+    throw new Error("diamondsFoundry.helpersDir must be a string");
+  }
+
+  // Validate generateExamples is boolean
+  if (typeof config.generateExamples !== "boolean") {
+    throw new Error("diamondsFoundry.generateExamples must be a boolean");
+  }
+
+  // Validate exampleTests is array
+  if (!Array.isArray(config.exampleTests)) {
+    throw new Error("diamondsFoundry.exampleTests must be an array");
+  }
+
+  // Validate exampleTests values
+  const validTests = ["unit", "integration", "fuzz"];
+  for (const test of config.exampleTests) {
+    if (!validTests.includes(test)) {
+      throw new Error(
+        `Invalid exampleTests value: ${test}. Must be one of: ${validTests.join(", ")}`
+      );
+    }
+  }
+
+  // Validate defaultNetwork is string
+  if (typeof config.defaultNetwork !== "string") {
+    throw new Error("diamondsFoundry.defaultNetwork must be a string");
+  }
+
+  // Validate reuseDeployment is boolean
+  if (typeof config.reuseDeployment !== "boolean") {
+    throw new Error("diamondsFoundry.reuseDeployment must be a boolean");
+  }
+
+  // Validate forgeTestArgs is array
+  if (!Array.isArray(config.forgeTestArgs)) {
+    throw new Error("diamondsFoundry.forgeTestArgs must be an array");
+  }
+
+  return config;
+}
+
+/**
+ * Check if a directory exists
+ */
+export function validateDirectoryExists(path: string): boolean {
+  return existsSync(path);
+}
+
+/**
+ * Validate output directory doesn't have conflicts
+ */
+export function validateOutputDirectory(
+  path: string,
+  force: boolean = false
+): void {
+  if (!force && validateDirectoryExists(path)) {
+    Logger.warn(`Output directory already exists: ${path}`);
+    Logger.info("Use --force to overwrite");
+    throw new Error("Output directory exists");
+  }
+}