@reactive-contracts/compiler 0.1.0-beta

package/dist/index.cli.js

@@ -0,0 +1,1094 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/init.ts
+import fse from "fs-extra";
+import { existsSync } from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/utils/logger.ts
+import pc from "picocolors";
+function success(message) {
+  console.log(pc.green("\u2713"), message);
+}
+function error(message) {
+  console.log(pc.red("\u2717"), message);
+}
+function warning(message) {
+  console.log(pc.yellow("\u26A0"), message);
+}
+function info(message) {
+  console.log(pc.blue("\u2139"), message);
+}
+function header(message) {
+  console.log("\n" + pc.bold(pc.cyan(message)) + "\n");
+}
+
+// src/cli/utils/spinner.ts
+import ora from "ora";
+var currentSpinner = null;
+function start(text) {
+  if (currentSpinner) {
+    currentSpinner.stop();
+  }
+  currentSpinner = ora(text).start();
+  return currentSpinner;
+}
+function succeed(text) {
+  if (currentSpinner) {
+    currentSpinner.succeed(text);
+    currentSpinner = null;
+  }
+}
+function fail(text) {
+  if (currentSpinner) {
+    currentSpinner.fail(text);
+    currentSpinner = null;
+  }
+}
+function stop() {
+  if (currentSpinner) {
+    currentSpinner.stop();
+    currentSpinner = null;
+  }
+}
+
+// src/cli/commands/init.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function getTemplatesDir() {
+  const templatesPath = path.join(__dirname, "templates");
+  if (!existsSync(templatesPath)) {
+    throw new Error(
+      `Templates directory not found at ${templatesPath}. Please rebuild the package.`
+    );
+  }
+  return templatesPath;
+}
+async function init() {
+  try {
+    header("Initializing Reactive Contracts");
+    const cwd = process.cwd();
+    start("Creating directory structure...");
+    await fse.ensureDir(path.join(cwd, "contracts"));
+    await fse.ensureDir(path.join(cwd, "generated", "frontend"));
+    await fse.ensureDir(path.join(cwd, "generated", "backend"));
+    await fse.ensureDir(path.join(cwd, "generated", "runtime"));
+    succeed("Created directory structure");
+    start("Creating config file...");
+    const configPath = path.join(cwd, "rcontracts.config.ts");
+    if (await fse.pathExists(configPath)) {
+      stop();
+      info("Config file already exists, skipping");
+    } else {
+      const templatePath = path.join(getTemplatesDir(), "rcontracts.config.template.ts");
+      await fse.copy(templatePath, configPath);
+      succeed("Created rcontracts.config.ts");
+    }
+    start("Updating .gitignore...");
+    const gitignorePath = path.join(cwd, ".gitignore");
+    let gitignoreContent = "";
+    if (await fse.pathExists(gitignorePath)) {
+      gitignoreContent = await fse.readFile(gitignorePath, "utf-8");
+    }
+    if (!gitignoreContent.includes("generated/")) {
+      const gitignoreTemplate = await fse.readFile(
+        path.join(getTemplatesDir(), "gitignore.template"),
+        "utf-8"
+      );
+      const updatedContent = gitignoreContent ? `${gitignoreContent}
+
+# Reactive Contracts
+${gitignoreTemplate}` : gitignoreTemplate;
+      await fse.writeFile(gitignorePath, updatedContent);
+      succeed("Updated .gitignore");
+    } else {
+      stop();
+      info(".gitignore already includes generated/, skipping");
+    }
+    start("Creating sample contract...");
+    const sampleContractPath = path.join(cwd, "contracts", "sample.contract.ts");
+    if (await fse.pathExists(sampleContractPath)) {
+      stop();
+      info("Sample contract already exists, skipping");
+    } else {
+      const sampleTemplatePath = path.join(getTemplatesDir(), "sample-contract.template.ts");
+      await fse.copy(sampleTemplatePath, sampleContractPath);
+      succeed("Created sample contract");
+    }
+    success("Initialization complete!");
+    console.log("\nNext steps:");
+    console.log("  1. Review the sample contract in contracts/sample.contract.ts");
+    console.log("  2. Customize rcontracts.config.ts if needed");
+    console.log("  3. Run: npx rcontracts compile");
+    console.log("  4. Check the generated/ directory for output");
+  } catch (err) {
+    fail("Initialization failed");
+    error(`Failed to initialize: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/compile.ts
+import { glob } from "glob";
+import * as path2 from "path";
+import { pathToFileURL } from "url";
+import { register } from "tsx/esm/api";
+
+// src/config/index.ts
+async function loadConfig(_configPath = "./rcontracts.config.ts") {
+  return {
+    contracts: "./contracts/**/*.contract.ts",
+    output: {
+      frontend: "./generated/frontend",
+      backend: "./generated/backend",
+      runtime: "./generated/runtime"
+    }
+  };
+}
+
+// src/validator/index.ts
+function validateContract(contract) {
+  const errors = [];
+  const warnings = [];
+  if (!contract || typeof contract !== "object") {
+    errors.push("Contract must be a valid object");
+    return { valid: false, errors, warnings };
+  }
+  if (contract._brand !== "Contract") {
+    errors.push("Invalid contract: missing _brand property");
+    return { valid: false, errors, warnings };
+  }
+  const { definition } = contract;
+  if (!definition.name || typeof definition.name !== "string") {
+    errors.push("Contract must have a valid name (non-empty string)");
+  } else if (!/^[A-Z][a-zA-Z0-9]*$/.test(definition.name)) {
+    warnings.push(
+      "Contract name should be in PascalCase (e.g., UserProfile, not userProfile or user_profile)"
+    );
+  }
+  if (!definition.intent || typeof definition.intent !== "string") {
+    errors.push("Contract must have a valid intent (non-empty string)");
+  } else if (definition.intent.length < 10) {
+    warnings.push("Intent should be descriptive (at least 10 characters)");
+  }
+  if (!definition.shape || typeof definition.shape !== "object") {
+    errors.push("Contract must have a valid shape definition");
+  } else {
+    validateShape(definition.shape, "", errors, warnings);
+  }
+  if (definition.constraints) {
+    validateConstraints(definition.constraints, errors, warnings);
+  }
+  if (definition.reactivity) {
+    validateReactivity(definition.reactivity, definition.shape, errors, warnings);
+  }
+  if (definition.versioning) {
+    validateVersioning(definition.versioning, errors, warnings);
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateShape(shape, path4, errors, warnings) {
+  if (!shape || typeof shape !== "object") {
+    errors.push(`Invalid shape at ${path4 || "root"}: must be an object`);
+    return;
+  }
+  const keys = Object.keys(shape);
+  if (keys.length === 0) {
+    warnings.push(`Shape at ${path4 || "root"} is empty`);
+  }
+  for (const key of keys) {
+    const fieldPath = path4 ? `${path4}.${key}` : key;
+    const value = shape[key];
+    if (!value) {
+      errors.push(`Field "${fieldPath}" has undefined value`);
+      continue;
+    }
+    if (!/^[a-z][a-zA-Z0-9]*$/.test(key)) {
+      warnings.push(
+        `Field name "${fieldPath}" should be in camelCase (e.g., firstName, not first_name)`
+      );
+    }
+    validateTypeDefinition(value, fieldPath, errors, warnings);
+  }
+}
+function validateTypeDefinition(type, path4, errors, warnings) {
+  if (typeof type === "string") {
+    const validPrimitives = ["string", "number", "boolean", "Date", "null", "undefined"];
+    const isURL = type === "URL" || type.startsWith("URL<");
+    if (!validPrimitives.includes(type) && !isURL) {
+      errors.push(`Invalid type at ${path4}: "${type}" is not a valid primitive or URL type`);
+    }
+    if (isURL && type !== "URL") {
+      const urlMatch = type.match(/^URL<(.+)>$/);
+      if (!urlMatch) {
+        errors.push(`Invalid URL type at ${path4}: must be "URL" or "URL<options>"`);
+      }
+    }
+  } else if (typeof type === "object" && type !== null) {
+    if ("_brand" in type && type._brand === "DerivedField") {
+      validateDerivedField(
+        type,
+        path4,
+        errors,
+        warnings
+      );
+    } else {
+      validateShape(type, path4, errors, warnings);
+    }
+  } else {
+    errors.push(`Invalid type at ${path4}: must be a string, object, or DerivedField`);
+  }
+}
+function validateDerivedField(field, path4, errors, _warnings) {
+  if (typeof field.derive !== "function") {
+    errors.push(`Derived field at ${path4} must have a derive function`);
+  }
+  if (field.dependencies && !Array.isArray(field.dependencies)) {
+    errors.push(`Derived field dependencies at ${path4} must be an array`);
+  }
+  if (field.preferredLayer && !["client", "edge", "origin"].includes(field.preferredLayer)) {
+    errors.push(`Derived field preferredLayer at ${path4} must be 'client', 'edge', or 'origin'`);
+  }
+  if (field.dependencies && Array.isArray(field.dependencies)) {
+    for (const dep of field.dependencies) {
+      if (typeof dep !== "string") {
+        errors.push(`Derived field dependency at ${path4} must be a string`);
+      }
+    }
+  }
+}
+function validateConstraints(constraints, errors, _warnings) {
+  if (constraints.latency) {
+    const { max, fallback } = constraints.latency;
+    if (!max || typeof max !== "string") {
+      errors.push('Latency constraint must have a max value (e.g., "100ms")');
+    } else {
+      if (!/^\d+(ms|s|m)$/.test(max)) {
+        errors.push(`Invalid latency max format: "${max}". Use format like "100ms", "1s", or "1m"`);
+      }
+    }
+    if (fallback && !["cachedVersion", "degraded", "error"].includes(fallback)) {
+      errors.push('Latency fallback must be "cachedVersion", "degraded", or "error"');
+    }
+  }
+  if (constraints.freshness) {
+    const { maxAge, staleWhileRevalidate } = constraints.freshness;
+    if (!maxAge || typeof maxAge !== "string") {
+      errors.push("Freshness constraint must have a maxAge value");
+    } else if (!/^\d+(ms|s|m|h|d)$/.test(maxAge)) {
+      errors.push(
+        `Invalid freshness maxAge format: "${maxAge}". Use format like "5m", "1h", or "1d"`
+      );
+    }
+    if (staleWhileRevalidate && !/^\d+(ms|s|m|h|d)$/.test(staleWhileRevalidate)) {
+      errors.push(
+        `Invalid staleWhileRevalidate format: "${staleWhileRevalidate}". Use format like "5m", "1h", or "1d"`
+      );
+    }
+  }
+  if (constraints.availability) {
+    const { uptime, gracefulDegradation } = constraints.availability;
+    if (!uptime || typeof uptime !== "string") {
+      errors.push("Availability constraint must have an uptime value");
+    } else if (!/^\d+(\.\d+)?%$/.test(uptime)) {
+      errors.push(`Invalid uptime format: "${uptime}". Use format like "99.9%"`);
+    }
+    if (gracefulDegradation !== void 0 && typeof gracefulDegradation !== "boolean") {
+      errors.push("Availability gracefulDegradation must be a boolean");
+    }
+  }
+}
+function validateReactivity(reactivity, shape, errors, warnings) {
+  const allFields = /* @__PURE__ */ new Set();
+  collectFieldPaths(shape, "", allFields);
+  if (reactivity.realtime) {
+    if (!Array.isArray(reactivity.realtime)) {
+      errors.push("Reactivity realtime must be an array of field paths");
+    } else {
+      for (const field of reactivity.realtime) {
+        if (typeof field !== "string") {
+          errors.push("Realtime field must be a string");
+        } else if (!allFields.has(field)) {
+          warnings.push(`Realtime field "${field}" does not exist in shape`);
+        }
+      }
+    }
+  }
+  if (reactivity.static) {
+    if (!Array.isArray(reactivity.static)) {
+      errors.push("Reactivity static must be an array of field paths");
+    } else {
+      for (const field of reactivity.static) {
+        if (typeof field !== "string") {
+          errors.push("Static field must be a string");
+        } else if (!allFields.has(field)) {
+          warnings.push(`Static field "${field}" does not exist in shape`);
+        }
+      }
+    }
+  }
+  if (reactivity.polling) {
+    if (!Array.isArray(reactivity.polling)) {
+      errors.push("Reactivity polling must be an array");
+    } else {
+      for (const config of reactivity.polling) {
+        if (!config.field || typeof config.field !== "string") {
+          errors.push("Polling config must have a field property");
+        } else if (!allFields.has(config.field)) {
+          warnings.push(`Polling field "${config.field}" does not exist in shape`);
+        }
+        if (!config.interval || typeof config.interval !== "string") {
+          errors.push("Polling config must have an interval property");
+        } else if (!/^\d+(ms|s|m)$/.test(config.interval)) {
+          errors.push(
+            `Invalid polling interval format: "${config.interval}". Use format like "30s" or "5m"`
+          );
+        }
+      }
+    }
+  }
+  if (reactivity.eventDriven) {
+    if (!Array.isArray(reactivity.eventDriven)) {
+      errors.push("Reactivity eventDriven must be an array");
+    } else {
+      for (const config of reactivity.eventDriven) {
+        if (!config.field || typeof config.field !== "string") {
+          errors.push("EventDriven config must have a field property");
+        } else if (!allFields.has(config.field)) {
+          warnings.push(`EventDriven field "${config.field}" does not exist in shape`);
+        }
+        if (!config.on || !Array.isArray(config.on)) {
+          errors.push('EventDriven config must have an "on" array of event names');
+        } else if (config.on.length === 0) {
+          warnings.push(`EventDriven config for "${config.field}" has no events`);
+        }
+      }
+    }
+  }
+}
+function validateVersioning(versioning, errors, warnings) {
+  if (!versioning.version || typeof versioning.version !== "string") {
+    errors.push("Versioning must have a version string");
+  } else if (!/^\d+\.\d+\.\d+$/.test(versioning.version)) {
+    warnings.push(`Version "${versioning.version}" should follow semver format (e.g., "1.0.0")`);
+  }
+  if (versioning.deprecated && !Array.isArray(versioning.deprecated)) {
+    errors.push("Versioning deprecated must be an array of field paths");
+  }
+  if (versioning.migration && typeof versioning.migration !== "function") {
+    errors.push("Versioning migration must be a function");
+  }
+}
+function collectFieldPaths(shape, prefix, result) {
+  for (const [key, value] of Object.entries(shape)) {
+    const path4 = prefix ? `${prefix}.${key}` : key;
+    result.add(path4);
+    if (typeof value === "object" && value !== null && !("_brand" in value) && typeof value !== "string") {
+      collectFieldPaths(value, path4, result);
+    }
+  }
+}
+
+// src/analyzer/index.ts
+function analyzeLatency(contract) {
+  const { definition } = contract;
+  const suggestions = [];
+  if (!definition.constraints?.latency) {
+    suggestions.push("Consider adding a latency constraint to ensure performance SLAs");
+    return {
+      status: "ok",
+      suggestions
+    };
+  }
+  const { max: maxLatency, fallback } = definition.constraints.latency;
+  const latencyMs = parseLatencyToMs(maxLatency);
+  if (latencyMs === null) {
+    return {
+      status: "error",
+      message: `Invalid latency format: ${maxLatency}`,
+      suggestions: ['Use format like "100ms", "1s", or "1m"']
+    };
+  }
+  const analysis = analyzeLatencyRequirement(latencyMs);
+  if (!fallback) {
+    suggestions.push("Consider specifying a fallback strategy (cachedVersion, degraded, or error)");
+  }
+  if (latencyMs < 50) {
+    suggestions.push(
+      "Very aggressive latency target (<50ms). Consider edge caching or CDN for static data."
+    );
+  } else if (latencyMs < 100) {
+    suggestions.push(
+      "Moderate latency target (<100ms). Ensure database queries are optimized and indexed."
+    );
+  } else if (latencyMs > 1e3) {
+    suggestions.push(
+      "High latency tolerance (>1s). Consider if this provides good user experience."
+    );
+  }
+  if (hasComplexDerivations(definition.shape)) {
+    suggestions.push(
+      "Contract contains derived fields. Consider computing these at edge or origin for better performance."
+    );
+  }
+  if (definition.reactivity?.realtime && definition.reactivity.realtime.length > 0) {
+    suggestions.push(
+      "Realtime fields require WebSocket connections. Ensure your infrastructure supports this."
+    );
+  }
+  return {
+    status: analysis.status,
+    estimated: analysis.estimated,
+    message: analysis.message,
+    suggestions
+  };
+}
+function parseLatencyToMs(latency) {
+  const match = latency.match(/^(\d+)(ms|s|m)$/);
+  if (!match || !match[1] || !match[2]) return null;
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    default:
+      return null;
+  }
+}
+function analyzeLatencyRequirement(latencyMs) {
+  if (latencyMs < 10) {
+    return {
+      status: "error",
+      estimated: "Typically 50-100ms for database queries",
+      message: "Latency target <10ms is extremely difficult to achieve consistently"
+    };
+  }
+  if (latencyMs < 50) {
+    return {
+      status: "warning",
+      estimated: "Requires edge caching or CDN",
+      message: "Latency target <50ms requires careful optimization"
+    };
+  }
+  if (latencyMs <= 200) {
+    return {
+      status: "ok",
+      estimated: "Achievable with optimized queries and caching",
+      message: "Latency target is reasonable for most applications"
+    };
+  }
+  if (latencyMs <= 1e3) {
+    return {
+      status: "ok",
+      estimated: "Easily achievable with standard backend",
+      message: "Latency target is conservative and should be easy to meet"
+    };
+  }
+  return {
+    status: "warning",
+    estimated: "Very high tolerance",
+    message: "Consider if this latency provides acceptable user experience"
+  };
+}
+function hasComplexDerivations(shape) {
+  if (!shape || typeof shape !== "object") {
+    return false;
+  }
+  for (const value of Object.values(shape)) {
+    if (typeof value === "object" && value !== null) {
+      if ("_brand" in value && value._brand === "DerivedField") {
+        return true;
+      }
+      if (hasComplexDerivations(value)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/generator/index.ts
+import { writeFile, mkdir } from "fs/promises";
+import { dirname as dirname2 } from "path";
+async function generateFrontendTypes(contract, outputPath) {
+  const { definition } = contract;
+  const typeName = definition.name;
+  const typeDefinitions = generateTypeDefinitions(definition.shape, `${typeName}Shape`);
+  const content = `/**
+ * Auto-generated types for ${typeName} contract
+ * DO NOT EDIT - This file is generated by @reactive-contracts/compiler
+ */
+
+import type { ContractStatus } from '@reactive-contracts/core';
+
+${typeDefinitions}
+
+/**
+ * Parameters for ${typeName} contract
+ */
+export interface ${typeName}Params {
+  // Add your params here based on contract requirements
+  [key: string]: unknown;
+}
+
+/**
+ * Full result type for ${typeName} contract
+ */
+export interface ${typeName}Result {
+  data: ${typeName}Shape;
+  status: ContractStatus;
+  metadata: {
+    executionTime: number;
+    cacheHit: boolean;
+    derivedAt: 'client' | 'edge' | 'origin';
+  };
+}
+
+/**
+ * Contract intent: ${definition.intent}
+ */
+export const ${typeName}Intent = '${definition.intent}' as const;
+`;
+  await mkdir(dirname2(outputPath), { recursive: true });
+  await writeFile(outputPath, content, "utf-8");
+}
+async function generateBackendResolver(contract, outputPath) {
+  const { definition } = contract;
+  const typeName = definition.name;
+  const shapeType = generateTypeDefinitions(definition.shape, `${typeName}ResolverShape`);
+  const content = `/**
+ * Auto-generated resolver template for ${typeName} contract
+ * Generated by @reactive-contracts/compiler
+ *
+ * Intent: ${definition.intent}
+ */
+
+import { implementContract } from '@reactive-contracts/server';
+import type { Contract } from '@reactive-contracts/core';
+import type { ResolverContext } from '@reactive-contracts/server';
+
+${shapeType}
+
+/**
+ * Implement the ${typeName} contract resolver
+ *
+ * This function should return data matching the contract shape.
+ * Derived fields will be computed automatically - don't include them.
+ */
+export const ${typeName}Resolver = implementContract(
+  // Import your contract definition here
+  {} as Contract, // Replace with your contract
+  {
+    async resolve(params: Record<string, unknown>, context: ResolverContext): Promise<${typeName}ResolverShape> {
+      // TODO: Implement your data fetching logic here
+
+      // Example:
+      // const data = await db.query(...);
+      // return {
+      //   // Map your data to match the contract shape
+      // };
+
+      throw new Error('${typeName}Resolver not implemented yet');
+    },
+
+    // Optional: Configure caching
+    cache: {
+      ttl: '5m',
+      staleWhileRevalidate: '1h',
+      tags: (params) => [\`${typeName.toLowerCase()}:\${params.id}\`],
+    },
+  }
+);
+`;
+  await mkdir(dirname2(outputPath), { recursive: true });
+  await writeFile(outputPath, content, "utf-8");
+}
+async function generateRuntimeNegotiator(contract, outputPath) {
+  const { definition } = contract;
+  const typeName = definition.name;
+  const content = `/**
+ * Auto-generated runtime negotiator for ${typeName} contract
+ * DO NOT EDIT - This file is generated by @reactive-contracts/compiler
+ */
+
+import type { Contract } from '@reactive-contracts/core';
+
+/**
+ * Runtime negotiator for ${typeName}
+ * Handles SLA monitoring, fallback logic, and performance tracking
+ */
+export class ${typeName}Negotiator {
+  private contract: Contract;
+  private metrics: {
+    executionTime: number[];
+    cacheHits: number;
+    cacheMisses: number;
+  } = {
+    executionTime: [],
+    cacheHits: 0,
+    cacheMisses: 0,
+  };
+
+  constructor(contract: Contract) {
+    this.contract = contract;
+  }
+
+  /**
+   * Execute contract with SLA monitoring
+   */
+  async execute<TData>(
+    resolver: () => Promise<TData>,
+    options?: {
+      useCache?: boolean;
+      timeout?: number;
+    }
+  ): Promise<{
+    data: TData;
+    status: {
+      latency: 'normal' | 'degraded' | 'violated';
+      freshness: 'fresh' | 'stale' | 'expired';
+      availability: 'available' | 'degraded' | 'unavailable';
+    };
+    metadata: {
+      executionTime: number;
+      cacheHit: boolean;
+      derivedAt: 'client' | 'edge' | 'origin';
+    };
+  }> {
+    const startTime = performance.now();
+
+    try {
+      // Execute resolver
+      const data = await resolver();
+      const executionTime = performance.now() - startTime;
+
+      // Track metrics
+      this.metrics.executionTime.push(executionTime);
+      if (options?.useCache) {
+        this.metrics.cacheHits++;
+      } else {
+        this.metrics.cacheMisses++;
+      }
+
+      // Determine latency status
+      const maxLatency = this.getMaxLatency();
+      const latencyStatus = this.evaluateLatency(executionTime, maxLatency);
+
+      return {
+        data,
+        status: {
+          latency: latencyStatus,
+          freshness: 'fresh',
+          availability: 'available',
+        },
+        metadata: {
+          executionTime,
+          cacheHit: options?.useCache ?? false,
+          derivedAt: 'origin',
+        },
+      };
+    } catch (error) {
+      // Handle fallback based on contract constraints
+      throw error;
+    }
+  }
+
+  /**
+   * Get metrics for monitoring
+   */
+  getMetrics() {
+    const avgExecutionTime =
+      this.metrics.executionTime.length > 0
+        ? this.metrics.executionTime.reduce((a, b) => a + b, 0) / this.metrics.executionTime.length
+        : 0;
+
+    return {
+      averageExecutionTime: avgExecutionTime,
+      p95ExecutionTime: this.calculateP95(),
+      cacheHitRate:
+        this.metrics.cacheHits / (this.metrics.cacheHits + this.metrics.cacheMisses) || 0,
+      totalExecutions: this.metrics.executionTime.length,
+    };
+  }
+
+  private getMaxLatency(): number {
+    const latency = this.contract.definition.constraints?.latency?.max;
+    if (!latency) return Infinity;
+
+    // Simple parsing for MVP
+    const match = latency.match(/^(\\d+)(ms|s|m)$/);
+    if (!match) return Infinity;
+
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+
+    switch (unit) {
+      case 'ms': return value;
+      case 's': return value * 1000;
+      case 'm': return value * 60 * 1000;
+      default: return Infinity;
+    }
+  }
+
+  private evaluateLatency(
+    executionTime: number,
+    maxLatency: number
+  ): 'normal' | 'degraded' | 'violated' {
+    if (executionTime <= maxLatency) {
+      return 'normal';
+    } else if (executionTime <= maxLatency * 1.5) {
+      return 'degraded';
+    } else {
+      return 'violated';
+    }
+  }
+
+  private calculateP95(): number {
+    if (this.metrics.executionTime.length === 0) return 0;
+
+    const sorted = [...this.metrics.executionTime].sort((a, b) => a - b);
+    const index = Math.floor(sorted.length * 0.95);
+    return sorted[index];
+  }
+}
+
+/**
+ * Create a new negotiator instance
+ */
+export function create${typeName}Negotiator(contract: Contract): ${typeName}Negotiator {
+  return new ${typeName}Negotiator(contract);
+}
+`;
+  await mkdir(dirname2(outputPath), { recursive: true });
+  await writeFile(outputPath, content, "utf-8");
+}
+function generateTypeDefinitions(shape, typeName) {
+  const fields = generateShapeFields(shape, 0);
+  return `export interface ${typeName} {
+${fields}
+}`;
+}
+function generateShapeFields(shape, indent) {
+  const indentStr = "  ".repeat(indent + 1);
+  const lines = [];
+  for (const [key, value] of Object.entries(shape)) {
+    const typeStr = generateTypeString(value, indent + 1);
+    lines.push(`${indentStr}${key}: ${typeStr};`);
+  }
+  return lines.join("\n");
+}
+function generateTypeString(type, indent) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "Date":
+        return "Date";
+      case "null":
+        return "null";
+      case "undefined":
+        return "undefined";
+      default:
+        if (type === "URL" || type.startsWith("URL<")) {
+          return "string";
+        }
+        return "any";
+    }
+  } else if (typeof type === "object" && type !== null) {
+    if ("_brand" in type && type._brand === "DerivedField") {
+      return "any";
+    } else {
+      const fields = generateShapeFields(type, indent);
+      const indentStr = "  ".repeat(indent);
+      return `{
+${fields}
+${indentStr}}`;
+    }
+  }
+  return "any";
+}
+
+// src/cli/commands/compile.ts
+var tsxUnregister = register();
+async function compile() {
+  try {
+    header("Compiling Reactive Contracts");
+    start("Loading configuration...");
+    const config = await loadConfig();
+    succeed("Configuration loaded");
+    start("Finding contract files...");
+    const contractFiles = await glob(config.contracts, {
+      cwd: process.cwd(),
+      absolute: true
+    });
+    if (contractFiles.length === 0) {
+      fail("No contract files found");
+      warning(`No files matching pattern: ${config.contracts}`);
+      info('Run "npx rcontracts init" to create a sample contract');
+      return;
+    }
+    succeed(`Found ${contractFiles.length} contract file(s)`);
+    let successCount = 0;
+    let errorCount = 0;
+    for (const file of contractFiles) {
+      const fileName = path2.basename(file, ".contract.ts");
+      start(`Processing ${fileName}...`);
+      try {
+        const fileUrl = pathToFileURL(file).href;
+        const module = await import(fileUrl);
+        const contractExports = Object.entries(module).filter(
+          ([key, value]) => key.endsWith("Contract") && typeof value === "object" && value !== null && "_brand" in value && value._brand === "Contract"
+        );
+        if (contractExports.length === 0) {
+          fail(`No contract found in ${fileName}`);
+          warning(`File ${file} does not export a contract`);
+          errorCount++;
+          continue;
+        }
+        for (const [exportName, contractObj] of contractExports) {
+          const contract = contractObj;
+          const validation = validateContract(contract);
+          if (!validation.valid) {
+            fail(`Validation failed for ${exportName}`);
+            for (const err of validation.errors) {
+              error(`  \u2717 ${err}`);
+            }
+            errorCount++;
+            continue;
+          }
+          if (validation.warnings.length > 0) {
+            for (const warn of validation.warnings) {
+              warning(`  \u26A0 ${warn}`);
+            }
+          }
+          const latencyAnalysis = analyzeLatency(contract);
+          if (latencyAnalysis.status === "error") {
+            fail(`Latency analysis failed for ${exportName}`);
+            error(`  \u2717 ${latencyAnalysis.message}`);
+            if (config.validation?.strictLatency) {
+              errorCount++;
+              continue;
+            }
+          } else if (latencyAnalysis.status === "warning") {
+            warning(`  \u26A0 ${latencyAnalysis.message}`);
+          }
+          if (latencyAnalysis.suggestions && latencyAnalysis.suggestions.length > 0) {
+            for (const suggestion of latencyAnalysis.suggestions) {
+              info(`  \u{1F4A1} ${suggestion}`);
+            }
+          }
+          const contractName = contract.definition.name;
+          const frontendPath = path2.join(
+            process.cwd(),
+            config.output.frontend,
+            `${contractName}.ts`
+          );
+          await generateFrontendTypes(contract, frontendPath);
+          const backendPath = path2.join(
+            process.cwd(),
+            config.output.backend,
+            `${contractName}.resolver.ts`
+          );
+          await generateBackendResolver(contract, backendPath);
+          const runtimePath = path2.join(
+            process.cwd(),
+            config.output.runtime,
+            `${contractName}.negotiator.ts`
+          );
+          await generateRuntimeNegotiator(contract, runtimePath);
+          succeed(`\u2713 Validated and generated code for ${exportName}`);
+          successCount++;
+        }
+      } catch (err) {
+        fail(`Failed to process ${fileName}`);
+        error(`  ${err instanceof Error ? err.message : String(err)}`);
+        errorCount++;
+      }
+    }
+    tsxUnregister();
+    console.log("");
+    if (successCount > 0) {
+      success(`\u2713 Successfully compiled ${successCount} contract(s)`);
+      info(`  Frontend types \u2192 ${config.output.frontend}`);
+      info(`  Backend resolvers \u2192 ${config.output.backend}`);
+      info(`  Runtime negotiators \u2192 ${config.output.runtime}`);
+    }
+    if (errorCount > 0) {
+      error(`\u2717 Failed to compile ${errorCount} contract(s)`);
+      process.exit(1);
+    }
+  } catch (err) {
+    error(`Failed to compile: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/validate.ts
+import { glob as glob2 } from "glob";
+import * as path3 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { register as register2 } from "tsx/esm/api";
+var tsxUnregister2 = register2();
+async function validate() {
+  try {
+    header("Validating Reactive Contracts");
+    start("Loading configuration...");
+    const config = await loadConfig();
+    succeed("Configuration loaded");
+    start("Finding contract files...");
+    const contractFiles = await glob2(config.contracts, {
+      cwd: process.cwd(),
+      absolute: true
+    });
+    if (contractFiles.length === 0) {
+      fail("No contract files found");
+      warning(`No files matching pattern: ${config.contracts}`);
+      info('Run "npx rcontracts init" to create a sample contract');
+      return;
+    }
+    succeed(`Found ${contractFiles.length} contract file(s)`);
+    let validCount = 0;
+    let invalidCount = 0;
+    let warningCount = 0;
+    for (const file of contractFiles) {
+      const fileName = path3.basename(file, ".contract.ts");
+      start(`Validating ${fileName}...`);
+      try {
+        const fileUrl = pathToFileURL2(file).href;
+        const module = await import(fileUrl);
+        const contractExports = Object.entries(module).filter(
+          ([key, value]) => key.endsWith("Contract") && typeof value === "object" && value !== null && "_brand" in value && value._brand === "Contract"
+        );
+        if (contractExports.length === 0) {
+          fail(`No contract found in ${fileName}`);
+          warning(`File ${file} does not export a contract`);
+          invalidCount++;
+          continue;
+        }
+        for (const [exportName, contractObj] of contractExports) {
+          const contract = contractObj;
+          const validation = validateContract(contract);
+          if (!validation.valid) {
+            fail(`\u2717 ${exportName} - INVALID`);
+            for (const err of validation.errors) {
+              error(`    ${err}`);
+            }
+            invalidCount++;
+          } else {
+            const latencyAnalysis = analyzeLatency(contract);
+            if (latencyAnalysis.status === "error") {
+              if (config.validation?.strictLatency) {
+                fail(`\u2717 ${exportName} - INVALID (latency constraint violation)`);
+                error(`    ${latencyAnalysis.message}`);
+                invalidCount++;
+              } else {
+                stop();
+                warning(`\u26A0 ${exportName} - WARNING (latency issue)`);
+                warning(`    ${latencyAnalysis.message}`);
+                warningCount++;
+                validCount++;
+              }
+            } else {
+              succeed(`\u2713 ${exportName} - VALID`);
+              validCount++;
+              if (validation.warnings.length > 0) {
+                for (const warn of validation.warnings) {
+                  warning(`    ${warn}`);
+                }
+                warningCount++;
+              }
+              if (latencyAnalysis.status === "warning") {
+                warning(`    ${latencyAnalysis.message}`);
+                warningCount++;
+              }
+              if (latencyAnalysis.suggestions && latencyAnalysis.suggestions.length > 0) {
+                for (const suggestion of latencyAnalysis.suggestions) {
+                  info(`    \u{1F4A1} ${suggestion}`);
+                }
+              }
+            }
+          }
+        }
+      } catch (err) {
+        fail(`Failed to validate ${fileName}`);
+        error(`  ${err instanceof Error ? err.message : String(err)}`);
+        invalidCount++;
+      }
+    }
+    tsxUnregister2();
+    console.log("");
+    console.log("Validation Summary:");
+    console.log(`  \u2713 Valid: ${validCount}`);
+    if (warningCount > 0) {
+      console.log(`  \u26A0 Warnings: ${warningCount}`);
+    }
+    if (invalidCount > 0) {
+      console.log(`  \u2717 Invalid: ${invalidCount}`);
+    }
+    if (invalidCount > 0) {
+      error("\nValidation failed. Please fix the errors above.");
+      process.exit(1);
+    } else if (warningCount > 0) {
+      success("\nValidation passed with warnings");
+    } else {
+      success("\nAll contracts are valid!");
+    }
+  } catch (err) {
+    error(`Failed to validate: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/diagnose.ts
+async function diagnose(name) {
+  try {
+    header(`Diagnosing Contract: ${name}`);
+    console.log(`
+Contract: ${name}`);
+    console.log("Status: Not implemented yet");
+  } catch (err) {
+    error(`Failed to diagnose: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/diff.ts
+async function diff() {
+  warning("The diff command is coming in beta!");
+  console.log("\nThis feature will show changes since the last compilation.");
+  console.log("Stay tuned for the beta release.");
+}
+
+// src/cli/commands/migrate.ts
+async function migrate() {
+  warning("The migrate command is coming in beta!");
+  console.log("\nThis feature will run contract migrations.");
+  console.log("Stay tuned for the beta release.");
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("rcontracts").description("Reactive Contracts CLI - Build-time compiler and validator").version("0.1.0-alpha");
+program.command("init").description("Initialize Reactive Contracts in your project").action(init);
+program.command("compile").description("Compile all contracts and generate code").action(compile);
+program.command("validate").description("Validate contracts without generating code").action(validate);
+program.command("diagnose <name>").description("Show detailed analysis for a specific contract").action(diagnose);
+program.command("diff").description("Show changes since last compile").action(diff);
+program.command("migrate").description("Run contract migrations").action(migrate);
+program.parse();