@a-company/paradigm 1.5.0

package/dist/test-MA5TWJQV.js

@@ -0,0 +1,934 @@
+#!/usr/bin/env node
+import {
+  parseGateConfig
+} from "./chunk-IRKUEJVW.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/portal/test.ts
+import * as path3 from "path";
+import * as fs3 from "fs";
+import chalk from "chalk";
+
+// ../portal/sdk/dist/chunk-BRTWJEZU.js
+var globalGateClient = null;
+function setGateClient(client) {
+  globalGateClient = client;
+}
+function getGateClient() {
+  return globalGateClient;
+}
+
+// ../portal/manager/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
+async function validateGateway(gateId, testCases, client) {
+  const gateClient = client || getGateClient();
+  if (!gateClient) {
+    return {
+      passed: false,
+      results: [],
+      errors: ["No gate client configured"]
+    };
+  }
+  const results = [];
+  const errors = [];
+  for (const testCase of testCases) {
+    try {
+      const result = await gateClient.check(gateId, testCase.entity);
+      const passed = result.passed === testCase.expected;
+      if (testCase.expectedPrizes && result.passed) {
+        const triggeredPrizeIds = result.triggeredPrizes.map((p) => p.id);
+        const missingPrizes = testCase.expectedPrizes.filter(
+          (id) => !triggeredPrizeIds.includes(id)
+        );
+        if (missingPrizes.length > 0) {
+          errors.push(
+            `Test "${testCase.name}": Expected prizes not triggered: ${missingPrizes.join(", ")}`
+          );
+        }
+      }
+      results.push({
+        testCase,
+        result,
+        passed
+      });
+      if (!passed) {
+        errors.push(
+          `Test "${testCase.name}": Expected ${testCase.expected ? "pass" : "fail"}, got ${result.passed ? "pass" : "fail"}`
+        );
+      }
+    } catch (error) {
+      errors.push(`Test "${testCase.name}": ${error.message}`);
+      results.push({
+        testCase,
+        result: {
+          gate: { id: gateId, locks: [], prizes: [] },
+          passed: false,
+          lockResults: [],
+          triggeredPrizes: [],
+          timestamp: Date.now()
+        },
+        passed: false
+      });
+    }
+  }
+  return {
+    passed: errors.length === 0,
+    results,
+    errors
+  };
+}
+async function generateTests(gateConfigPath, options = {}) {
+  const {
+    outputDir = "tests/gates",
+    framework = "jest",
+    includeFlows = true
+  } = options;
+  const gateConfig = await parseGateConfig(gateConfigPath);
+  const generatedFiles = [];
+  const absOutputDir = path.resolve(outputDir);
+  if (!fs.existsSync(absOutputDir)) {
+    fs.mkdirSync(absOutputDir, { recursive: true });
+  }
+  for (const gate of gateConfig.gates) {
+    const testFile = generateGateTest(gate, framework);
+    const fileName = `${gate.id.replace(/[^a-z0-9]/gi, "-")}.test.ts`;
+    const filePath = path.join(absOutputDir, fileName);
+    fs.writeFileSync(filePath, testFile, "utf8");
+    generatedFiles.push(filePath);
+  }
+  if (includeFlows && gateConfig.flows.length > 0) {
+    const flowsDir = path.join(absOutputDir, "..", "flows");
+    if (!fs.existsSync(flowsDir)) {
+      fs.mkdirSync(flowsDir, { recursive: true });
+    }
+    for (const flow of gateConfig.flows) {
+      const testFile = generateFlowTest(flow, gateConfig.gates, framework);
+      const fileName = `${flow.id.replace(/[^a-z0-9]/gi, "-")}.test.ts`;
+      const filePath = path.join(flowsDir, fileName);
+      fs.writeFileSync(filePath, testFile, "utf8");
+      generatedFiles.push(filePath);
+    }
+  }
+  return generatedFiles;
+}
+function generateGateTest(gate, framework) {
+  const testFn = framework === "mocha" ? "it" : framework === "vitest" ? "it" : "test";
+  const gateId = gate.id;
+  const gateName = gate.description || gateId;
+  const lockTests = gate.locks.map((lock) => {
+    const lockTests2 = lock.keys.map((key, idx) => {
+      return `    ${testFn}('should check key: ${key.description || `Key ${idx + 1}`}', async () => {
+      const entity = {
+        // TODO: Add entity properties needed for this key
+        // Key expression: ${key.expression}
+      };
+
+      const result = await checkGateway('${gateId}', entity);
+      // TODO: Assert expected result
+      expect(result.passed).toBeDefined();
+    });`;
+    });
+    return `  describe('Lock: ${lock.description || lock.id}', () => {
+${lockTests2.join("\n\n")}
+  });`;
+  });
+  return `/**
+ * Generated test file for gate: ${gateName}
+ * Gate ID: ${gateId}
+ * 
+ * TODO: Fill in entity mock data and expected results
+ */
+
+import { checkGateway, validateGateway } from '@a-company/portal-manager';
+import { createGate, setGateClient } from '@a-company/portal-sdk';
+import { parseGateConfig } from '@a-company/portal-core';
+
+${framework === "vitest" ? "import { describe, it, expect, beforeAll } from 'vitest';" : framework === "mocha" ? "import { describe, it } from 'mocha';" : "import { describe, test as it, expect, beforeAll } from '@jest/globals';"}
+
+describe('Gate: ${gateName}', () => {
+  beforeAll(async () => {
+    // Load gate configuration
+    const config = await parseGateConfig('./portal.yaml');
+    const client = createGate(config);
+    setGateClient(client);
+  });
+
+${lockTests.join("\n\n")}
+
+  ${testFn}('should trigger prizes when gate passes', async () => {
+    const entity = {
+      // TODO: Add entity that passes all locks
+    };
+
+    const result = await checkGateway('${gateId}', entity);
+    
+    if (result.passed) {
+      expect(result.triggeredPrizes.length).toBeGreaterThan(0);
+      // TODO: Assert specific prizes
+      ${gate.prizes.map((p) => `// expect(result.triggeredPrizes).toContainEqual(expect.objectContaining({ id: '${p.id}' }));`).join("\n      ")}
+    }
+  });
+});
+`;
+}
+function generateFlowTest(flow, _gates, framework) {
+  const testFn = framework === "mocha" ? "it" : framework === "vitest" ? "it" : "test";
+  const flowName = flow.description || flow.id;
+  const gateTests = flow.gates.map((gateId, idx) => {
+    return `    ${testFn}('should pass gate ${idx + 1}: ${gateId}', async () => {
+      const entity = {
+        // TODO: Add entity properties
+      };
+
+      const result = await checkGateway('${gateId}', entity);
+      expect(result.passed).toBe(true);
+    });`;
+  });
+  return `/**
+ * Generated test file for flow: ${flowName}
+ * Flow ID: ${flow.id}
+ * 
+ * TODO: Fill in entity mock data for each gate in the flow
+ */
+
+import { checkGateway } from '@a-company/portal-manager';
+import { createGate, setGateClient } from '@a-company/portal-sdk';
+import { parseGateConfig } from '@a-company/portal-core';
+
+${framework === "vitest" ? "import { describe, it, expect, beforeAll } from 'vitest';" : framework === "mocha" ? "import { describe, it } from 'mocha';" : "import { describe, test as it, expect, beforeAll } from '@jest/globals';"}
+
+describe('Flow: ${flowName}', () => {
+  beforeAll(async () => {
+    const config = await parseGateConfig('./portal.yaml');
+    const client = createGate(config);
+    setGateClient(client);
+  });
+
+  ${testFn}('should complete entire flow', async () => {
+    const entity = {
+      // TODO: Add entity that passes all gates in flow
+    };
+
+${gateTests.join("\n\n")}
+  });
+});
+`;
+}
+async function scanComponents(options) {
+  const { rootDir, patterns = ["**/*.tsx", "**/*.jsx"] } = options;
+  const components = [];
+  const scannedFiles = /* @__PURE__ */ new Set();
+  function scanDirectory(dir) {
+    try {
+      const entries = fs2.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path2.join(dir, entry.name);
+        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist" || entry.name === "build") {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          scanDirectory(fullPath);
+        } else if (entry.isFile()) {
+          const matchesPattern = patterns.some((pattern) => {
+            if (pattern.includes("**")) {
+              const ext = pattern.split(".").pop();
+              return fullPath.endsWith(`.${ext}`);
+            }
+            return fullPath.endsWith(pattern);
+          });
+          if (matchesPattern && !scannedFiles.has(fullPath)) {
+            scannedFiles.add(fullPath);
+            const info = analyzeComponent(fullPath);
+            if (info) {
+              components.push(info);
+            }
+          }
+        }
+      }
+    } catch (error) {
+    }
+  }
+  scanDirectory(rootDir);
+  return components;
+}
+function analyzeComponent(filePath) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf8");
+    const componentName = path2.basename(filePath, path2.extname(filePath));
+    const gatePatterns = [
+      /@Gate\(['"]([^'"]+)['"]\)/g,
+      /@Gateway\(['"]([^'"]+)['"]\)/g,
+      /GateGuard\(['"]([^'"]+)['"]\)/g,
+      /checkGateway\(['"]([^'"]+)['"]/g,
+      /gate:\s*['"]([^'"]+)['"]/g
+    ];
+    const requiredGates = /* @__PURE__ */ new Set();
+    const missingChecks = [];
+    for (const pattern of gatePatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const gateId = match[1];
+        if (gateId && gateId.startsWith("^")) {
+          requiredGates.add(gateId);
+        }
+      }
+    }
+    const hasGateCheck = content.includes("checkGateway") || content.includes("GateGuard") || content.includes("Gateway") || content.includes("useGate");
+    if (requiredGates.size > 0 && !hasGateCheck) {
+      missingChecks.push(...Array.from(requiredGates));
+    }
+    return {
+      filePath,
+      componentName,
+      requiredGates: Array.from(requiredGates),
+      missingChecks
+    };
+  } catch (error) {
+    return null;
+  }
+}
+function generateComponentReport(components) {
+  const lines = [];
+  lines.push("# Component Access Report\n");
+  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+  lines.push(`Total Components: ${components.length}
+`);
+  const withMissingChecks = components.filter((c) => c.missingChecks.length > 0);
+  if (withMissingChecks.length > 0) {
+    lines.push(`
+## Components Missing Gate Checks (${withMissingChecks.length})
+`);
+    for (const component of withMissingChecks) {
+      lines.push(`### ${component.componentName}`);
+      lines.push(`File: ${component.filePath}`);
+      lines.push(`Missing checks for gates: ${component.missingChecks.join(", ")}
+`);
+    }
+  } else {
+    lines.push("\n\u2705 All components have proper gate checks!\n");
+  }
+  return lines.join("\n");
+}
+
+// ../portal/sdk/dist/index.js
+function tokenize(expr) {
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    const char = expr[i];
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const quote = char;
+      let str = "";
+      i++;
+      while (i < expr.length && expr[i] !== quote) {
+        if (expr[i] === "\\" && i + 1 < expr.length) {
+          i++;
+          str += expr[i];
+        } else {
+          str += expr[i];
+        }
+        i++;
+      }
+      i++;
+      tokens.push({ type: "STRING", value: str });
+      continue;
+    }
+    if (/\d/.test(char)) {
+      let num = "";
+      while (i < expr.length && /[\d.]/.test(expr[i])) {
+        num += expr[i];
+        i++;
+      }
+      tokens.push({ type: "NUMBER", value: num });
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(char)) {
+      let ident = "";
+      while (i < expr.length && /[a-zA-Z0-9_]/.test(expr[i])) {
+        ident += expr[i];
+        i++;
+      }
+      if (ident === "true" || ident === "false") {
+        tokens.push({ type: "BOOLEAN", value: ident });
+      } else if (ident === "null" || ident === "undefined") {
+        tokens.push({ type: "NULL", value: ident });
+      } else if (["and", "or", "not", "includes", "in"].includes(ident)) {
+        tokens.push({ type: "OPERATOR", value: ident });
+      } else {
+        tokens.push({ type: "IDENTIFIER", value: ident });
+      }
+      continue;
+    }
+    if (expr.slice(i, i + 3) === "===" || expr.slice(i, i + 3) === "!==") {
+      tokens.push({ type: "OPERATOR", value: expr.slice(i, i + 3) });
+      i += 3;
+      continue;
+    }
+    if (expr.slice(i, i + 2) === "==" || expr.slice(i, i + 2) === "!=" || expr.slice(i, i + 2) === "<=" || expr.slice(i, i + 2) === ">=" || expr.slice(i, i + 2) === "&&" || expr.slice(i, i + 2) === "||") {
+      tokens.push({ type: "OPERATOR", value: expr.slice(i, i + 2) });
+      i += 2;
+      continue;
+    }
+    if ("<>=!".includes(char)) {
+      tokens.push({ type: "OPERATOR", value: char });
+      i++;
+      continue;
+    }
+    if (char === "(") {
+      tokens.push({ type: "LPAREN", value: char });
+      i++;
+      continue;
+    }
+    if (char === ")") {
+      tokens.push({ type: "RPAREN", value: char });
+      i++;
+      continue;
+    }
+    if (char === ".") {
+      tokens.push({ type: "DOT", value: char });
+      i++;
+      continue;
+    }
+    if (char === ",") {
+      tokens.push({ type: "COMMA", value: char });
+      i++;
+      continue;
+    }
+    i++;
+  }
+  tokens.push({ type: "EOF", value: "" });
+  return tokens;
+}
+var ExpressionEvaluator = class {
+  tokens;
+  pos;
+  context;
+  constructor(tokens, context) {
+    this.tokens = tokens;
+    this.pos = 0;
+    this.context = context;
+  }
+  current() {
+    return this.tokens[this.pos] || { type: "EOF", value: "" };
+  }
+  advance() {
+    const token = this.current();
+    this.pos++;
+    return token;
+  }
+  evaluate() {
+    return this.parseOr();
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.current().value === "||" || this.current().value === "or") {
+      this.advance();
+      const right = this.parseAnd();
+      left = Boolean(left) || Boolean(right);
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.current().value === "&&" || this.current().value === "and") {
+      this.advance();
+      const right = this.parseNot();
+      left = Boolean(left) && Boolean(right);
+    }
+    return left;
+  }
+  parseNot() {
+    if (this.current().value === "!" || this.current().value === "not") {
+      this.advance();
+      return !Boolean(this.parseNot());
+    }
+    return this.parseComparison();
+  }
+  parseComparison() {
+    let left = this.parsePrimary();
+    const op = this.current();
+    if (op.type === "OPERATOR") {
+      switch (op.value) {
+        case "==":
+        case "===":
+          this.advance();
+          return left === this.parsePrimary();
+        case "!=":
+        case "!==":
+          this.advance();
+          return left !== this.parsePrimary();
+        case "<":
+          this.advance();
+          return left < this.parsePrimary();
+        case ">":
+          this.advance();
+          return left > this.parsePrimary();
+        case "<=":
+          this.advance();
+          return left <= this.parsePrimary();
+        case ">=":
+          this.advance();
+          return left >= this.parsePrimary();
+        case "includes":
+          this.advance();
+          const includesValue = this.parsePrimary();
+          if (Array.isArray(left)) {
+            return left.includes(includesValue);
+          }
+          if (typeof left === "string") {
+            return left.includes(String(includesValue));
+          }
+          return false;
+        case "in":
+          this.advance();
+          const inArray = this.parsePrimary();
+          if (Array.isArray(inArray)) {
+            return inArray.includes(left);
+          }
+          return false;
+      }
+    }
+    return left;
+  }
+  parsePrimary() {
+    const token = this.current();
+    if (token.type === "LPAREN") {
+      this.advance();
+      const value = this.parseOr();
+      if (this.current().type === "RPAREN") {
+        this.advance();
+      }
+      return value;
+    }
+    if (token.type === "STRING") {
+      this.advance();
+      return token.value;
+    }
+    if (token.type === "NUMBER") {
+      this.advance();
+      return parseFloat(token.value);
+    }
+    if (token.type === "BOOLEAN") {
+      this.advance();
+      return token.value === "true";
+    }
+    if (token.type === "NULL") {
+      this.advance();
+      return null;
+    }
+    if (token.type === "IDENTIFIER") {
+      return this.parseIdentifier();
+    }
+    return null;
+  }
+  parseIdentifier() {
+    let value = this.context;
+    while (this.current().type === "IDENTIFIER" || this.current().type === "DOT") {
+      if (this.current().type === "DOT") {
+        this.advance();
+        continue;
+      }
+      const key = this.advance().value;
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        value = value[key];
+      } else {
+        value = void 0;
+      }
+      if (this.current().type === "LPAREN") {
+        this.advance();
+        const args = [];
+        while (this.current().type !== "RPAREN" && this.current().type !== "EOF") {
+          args.push(this.parseOr());
+          if (this.current().type === "COMMA") {
+            this.advance();
+          }
+        }
+        if (this.current().type === "RPAREN") {
+          this.advance();
+        }
+        return this.callMethod(key, value, args);
+      }
+      if (this.current().type !== "DOT") {
+        break;
+      }
+    }
+    return value;
+  }
+  callMethod(method, target, args) {
+    switch (method) {
+      case "includes":
+        if (Array.isArray(target)) {
+          return target.includes(args[0]);
+        }
+        if (typeof target === "string") {
+          return target.includes(String(args[0]));
+        }
+        return false;
+      case "startsWith":
+        if (typeof target === "string") {
+          return target.startsWith(String(args[0]));
+        }
+        return false;
+      case "endsWith":
+        if (typeof target === "string") {
+          return target.endsWith(String(args[0]));
+        }
+        return false;
+      case "length":
+        if (Array.isArray(target) || typeof target === "string") {
+          return target.length;
+        }
+        return 0;
+      default:
+        return null;
+    }
+  }
+};
+function evaluateExpression(expression, context) {
+  try {
+    const tokens = tokenize(expression);
+    const evaluator = new ExpressionEvaluator(tokens, context);
+    const result = evaluator.evaluate();
+    return {
+      passed: Boolean(result)
+    };
+  } catch (error) {
+    return {
+      passed: false,
+      error: error.message
+    };
+  }
+}
+var GateClient = class {
+  config;
+  prizeHandlers = /* @__PURE__ */ new Map();
+  firedPrizes = [];
+  ws = null;
+  options;
+  entityIdResolver;
+  constructor(config, options = {}) {
+    this.config = config;
+    this.options = options;
+    this.entityIdResolver = options.entityIdResolver || this.defaultEntityIdResolver;
+    if (options.devMode) {
+      this.connectWatcher();
+    }
+  }
+  /**
+   * Default entity ID resolver - looks for id, _id, userId, entityId
+   */
+  defaultEntityIdResolver(entity) {
+    return entity.id || entity._id || entity.userId || entity.entityId || "anonymous";
+  }
+  /**
+   * Connect to the Gate watcher server
+   */
+  connectWatcher() {
+    const url = this.options.watcherUrl || `ws://localhost:${this.config.settings.dev.watcherPort}`;
+    try {
+      if (typeof WebSocket !== "undefined") {
+        this.ws = new WebSocket(url);
+        this.ws.onopen = () => {
+          console.log("[Gate SDK] Connected to watcher");
+        };
+        this.ws.onerror = () => {
+          console.warn("[Gate SDK] Failed to connect to watcher");
+        };
+        this.ws.onclose = () => {
+          setTimeout(() => this.connectWatcher(), 5e3);
+        };
+      }
+    } catch {
+      console.warn("[Gate SDK] WebSocket not available for watcher connection");
+    }
+  }
+  /**
+   * Send event to watcher
+   */
+  sendWatcherEvent(event) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(event));
+    }
+  }
+  /**
+   * Register a handler for a prize
+   */
+  onPrize(prizeId, handler) {
+    if (!this.prizeHandlers.has(prizeId)) {
+      this.prizeHandlers.set(prizeId, []);
+    }
+    this.prizeHandlers.get(prizeId).push(handler);
+    return () => {
+      const handlers = this.prizeHandlers.get(prizeId);
+      if (handlers) {
+        const index = handlers.indexOf(handler);
+        if (index >= 0) {
+          handlers.splice(index, 1);
+        }
+      }
+    };
+  }
+  /**
+   * Check if an entity can pass through a gate
+   */
+  async check(gateId, entity) {
+    const gate = this.config.gates.find((g) => g.id === gateId);
+    if (!gate) {
+      throw new Error(`Gate not found: ${gateId}`);
+    }
+    const entityId = this.entityIdResolver(entity);
+    const timestamp = Date.now();
+    this.sendWatcherEvent({
+      type: "gate:check",
+      timestamp,
+      entityId,
+      data: { gate, entitySnapshot: entity }
+    });
+    const lockResults = [];
+    let allLocksPassed = true;
+    for (const lock of gate.locks) {
+      const keyResults = [];
+      let lockPassed;
+      if (lock.mode === "any") {
+        lockPassed = false;
+        for (const key of lock.keys) {
+          const { passed, error } = evaluateExpression(key.expression, entity);
+          keyResults.push({ key, passed, error });
+          if (passed) {
+            lockPassed = true;
+          }
+        }
+      } else {
+        lockPassed = true;
+        for (const key of lock.keys) {
+          const { passed, error } = evaluateExpression(key.expression, entity);
+          keyResults.push({ key, passed, error });
+          if (!passed) {
+            lockPassed = false;
+          }
+        }
+      }
+      lockResults.push({
+        lock,
+        passed: lockPassed,
+        keyResults
+      });
+      if (!lockPassed) {
+        allLocksPassed = false;
+      }
+    }
+    const triggeredPrizes = [];
+    if (allLocksPassed) {
+      for (const prize of gate.prizes) {
+        if (prize.oneTime) {
+          const alreadyFired = this.firedPrizes.some(
+            (fp) => fp.entityId === entityId && fp.prizeId === prize.id
+          );
+          if (alreadyFired) {
+            continue;
+          }
+        }
+        triggeredPrizes.push(prize);
+        if (prize.oneTime) {
+          this.firedPrizes.push({
+            entityId,
+            prizeId: prize.id,
+            timestamp
+          });
+        }
+        const handlers = this.prizeHandlers.get(prize.id) || [];
+        for (const handler of handlers) {
+          try {
+            await handler(entity, {
+              gate,
+              prize,
+              timestamp
+            });
+          } catch (error) {
+            console.error(`[Gate SDK] Prize handler error for ${prize.id}:`, error);
+          }
+        }
+        this.sendWatcherEvent({
+          type: "prize:fire",
+          timestamp: Date.now(),
+          entityId,
+          data: { prizeId: prize.id, metadata: prize.metadata }
+        });
+      }
+    }
+    const result = {
+      gate,
+      passed: allLocksPassed,
+      lockResults,
+      triggeredPrizes,
+      timestamp,
+      entitySnapshot: entity
+    };
+    this.sendWatcherEvent({
+      type: allLocksPassed ? "gate:pass" : "gate:fail",
+      timestamp: Date.now(),
+      entityId,
+      data: result
+    });
+    return result;
+  }
+  /**
+   * Get a gate by ID
+   */
+  getGate(gateId) {
+    return this.config.gates.find((g) => g.id === gateId);
+  }
+  /**
+   * Get all gates
+   */
+  getGates() {
+    return this.config.gates;
+  }
+  /**
+   * Get all flows
+   */
+  getFlows() {
+    return this.config.flows;
+  }
+  /**
+   * Reset fired prizes for an entity (useful for testing)
+   */
+  resetPrizes(entityId) {
+    if (entityId) {
+      this.firedPrizes = this.firedPrizes.filter((fp) => fp.entityId !== entityId);
+    } else {
+      this.firedPrizes = [];
+    }
+  }
+  /**
+   * Disconnect from watcher
+   */
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+};
+async function createGate(configPath, options = {}) {
+  const config = await parseGateConfig(configPath);
+  const devMode = options.devMode ?? process.env.NODE_ENV !== "production";
+  return new GateClient(config, {
+    ...options,
+    devMode
+  });
+}
+var isProduction = typeof process !== "undefined" ? process.env.NODE_ENV === "production" : typeof import.meta !== "undefined" && import.meta.env?.PROD;
+var enableValidation = typeof process !== "undefined" ? process.env.PORTAL_VALIDATION === "true" : typeof import.meta !== "undefined" && import.meta.env?.VITE_ENABLE_PORTAL_VALIDATION === "true";
+var isTestMode = typeof process !== "undefined" ? process.env.PORTAL_TEST_MODE === "true" : typeof import.meta !== "undefined" && import.meta.env?.VITE_TEST_MODE === "true";
+
+// src/commands/portal/test.ts
+async function gateTestCommand(targetPath, options) {
+  const rootDir = targetPath ? path3.resolve(targetPath) : process.cwd();
+  const gateConfigPath = path3.join(rootDir, "portal.yaml");
+  if (!fs3.existsSync(gateConfigPath)) {
+    console.error(chalk.red(`\u274C portal.yaml not found at ${gateConfigPath}`));
+    console.error(chalk.gray("   Run `paradigm init` or create portal.yaml manually"));
+    process.exit(1);
+  }
+  if (options.generate) {
+    console.log(chalk.blue("\n\u{1F527} Generating test files...\n"));
+    try {
+      const generatedFiles = await generateTests(gateConfigPath, {
+        outputDir: options.output || "tests/gates",
+        framework: options.framework || "jest",
+        includeFlows: true
+      });
+      console.log(chalk.green(`\u2705 Generated ${generatedFiles.length} test files:`));
+      for (const file of generatedFiles) {
+        console.log(chalk.gray(`   ${path3.relative(rootDir, file)}`));
+      }
+      console.log("");
+    } catch (error) {
+      console.error(chalk.red(`\u274C Error generating tests: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+  if (options.component) {
+    console.log(chalk.blue("\n\u{1F50D} Scanning components for gate checks...\n"));
+    try {
+      const components = await scanComponents({
+        rootDir,
+        gateConfigPath
+      });
+      const report = generateComponentReport(components);
+      console.log(report);
+      const withMissing = components.filter((c) => c.missingChecks.length > 0);
+      if (withMissing.length > 0) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red(`\u274C Error scanning components: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+  if (options.gate) {
+    console.log(chalk.blue(`
+\u{1F9EA} Testing gate: ${options.gate}
+`));
+    try {
+      const config = await parseGateConfig(gateConfigPath);
+      const client = await createGate(gateConfigPath);
+      setGateClient(client);
+      const gate = config.gates.find((g) => g.id === options.gate);
+      if (!gate) {
+        console.error(chalk.red(`\u274C Gate "${options.gate}" not found`));
+        process.exit(1);
+      }
+      const testCases = [
+        {
+          name: "Empty entity (should fail)",
+          entity: {},
+          expected: false
+        },
+        {
+          name: "Entity with required properties",
+          entity: {
+            // TODO: Add properties based on gate locks
+            user: { id: "test-user" }
+          },
+          expected: true
+        }
+      ];
+      const result = await validateGateway(options.gate, testCases, client);
+      if (result.passed) {
+        console.log(chalk.green("\u2705 All tests passed\n"));
+      } else {
+        console.log(chalk.red("\u274C Some tests failed\n"));
+        for (const error of result.errors) {
+          console.log(chalk.red(`   ${error}`));
+        }
+        console.log("");
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red(`\u274C Error testing gate: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+  console.log(chalk.blue("\n\u{1F9EA} Portal Testing\n"));
+  console.log("Usage:");
+  console.log("  paradigm portal test --generate             Generate test files");
+  console.log("  paradigm portal test --portal ^auth-required  Test specific portal");
+  console.log("  paradigm portal test --component             Validate component access");
+  console.log("");
+}
+export {
+  gateTestCommand
+};