@williambeto/ai-workflow 2.4.8 → 2.6.3

package/chunk-2AOV2ATY.js

@@ -0,0 +1,749 @@
+// src/core/gates/merge-gate.ts
+import { execSync } from "child_process";
+var MergeGate = class {
+  cwd;
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+  }
+  runGit(command) {
+    return execSync(command, {
+      cwd: this.cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  }
+  /**
+   * Checks the commit history of the repository/branch.
+   */
+  check(branchName) {
+    try {
+      const logOutput = this.runGit('git log -n 50 --format="%H|%P|%s"');
+      const lines = logOutput.split("\n").filter(Boolean);
+      const commits = lines.map((line) => {
+        const parts = line.split("|");
+        const hash = parts[0] || "";
+        const parentsStr = parts[1] || "";
+        const parents = parentsStr.split(" ").filter(Boolean);
+        const subject = parts[2] || "";
+        return { hash, parents, subject };
+      });
+      for (const commit of commits) {
+        const isMergeSubject = /merge\b/i.test(commit.subject) || /pull request/i.test(commit.subject);
+        if (isMergeSubject && commit.parents.length < 2) {
+          return {
+            status: "FAIL_QUALITY_GATE",
+            reason: `Linear or fast-forward merge detected for commit '${commit.hash.slice(0, 7)}' ("${commit.subject}"). Merges into integration branches must use the non-fast-forward (--no-ff) strategy to preserve topology.`
+          };
+        }
+      }
+      const isIntegrationBranch = ["main", "master"].includes(branchName) || String(branchName).startsWith("release");
+      if (isIntegrationBranch && commits.length > 5) {
+        const hasMergeCommit = commits.some((c) => c.parents.length >= 2);
+        if (!hasMergeCommit) {
+          return {
+            status: "FAIL_QUALITY_GATE",
+            reason: `Integration branch '${branchName}' has a purely linear commit history. Integrated branches must use non-fast-forward (--no-ff) merges to preserve feature branches.`
+          };
+        }
+      }
+      return { status: "PASS" };
+    } catch (error) {
+      return {
+        status: "ERROR",
+        reason: `Failed to check merge integrity: ${error.message}`
+      };
+    }
+  }
+};
+
+// src/core/validation/stack-detector.ts
+import fs from "fs/promises";
+import path from "path";
+var StackDetector = class {
+  cwd;
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+  }
+  async detect() {
+    const stacks = [];
+    const packageJsonExists = await fs.access(path.join(this.cwd, "package.json")).then(() => true).catch(() => false);
+    if (packageJsonExists) {
+      stacks.push("node");
+    }
+    const pyprojectExists = await fs.access(path.join(this.cwd, "pyproject.toml")).then(() => true).catch(() => false) || await fs.access(path.join(this.cwd, "requirements.txt")).then(() => true).catch(() => false) || await fs.access(path.join(this.cwd, "setup.py")).then(() => true).catch(() => false) || await fs.access(path.join(this.cwd, "Pipfile")).then(() => true).catch(() => false);
+    let hasPythonFiles = pyprojectExists;
+    if (!hasPythonFiles) {
+      hasPythonFiles = await this.hasFileWithExtension(this.cwd, ".py");
+    }
+    if (hasPythonFiles) {
+      stacks.push("python");
+    }
+    const composerExists = await fs.access(path.join(this.cwd, "composer.json")).then(() => true).catch(() => false);
+    let hasPhpFiles = composerExists;
+    if (!hasPhpFiles) {
+      hasPhpFiles = await this.hasFileWithExtension(this.cwd, ".php");
+    }
+    if (hasPhpFiles) {
+      stacks.push("php");
+    }
+    return stacks;
+  }
+  async hasFileWithExtension(dir, ext) {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (["node_modules", "vendor", ".git", "dist", "build", ".cache"].includes(entry.name)) {
+            continue;
+          }
+          const subPath = path.join(dir, entry.name);
+          const found = await this.hasFileWithExtension(subPath, ext);
+          if (found) return true;
+        } else if (entry.isFile() && entry.name.endsWith(ext)) {
+          return true;
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+};
+
+// src/core/validation/delivery-decision-engine.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+function parseRequest(request = "") {
+  const req = request.toLowerCase();
+  let targetStack = null;
+  if (/\b(vue|nuxt|quasar)\b/.test(req)) targetStack = "vue";
+  else if (/\b(react|next)\b/.test(req)) targetStack = "react";
+  else if (/\b(angular|svelte)\b/.test(req)) targetStack = "svelte-or-angular";
+  else if (/\b(laravel|django|rails|express|nest|fastify)\b/.test(req)) {
+    if (/\blaravel\b/.test(req)) targetStack = "laravel";
+    else targetStack = "backend";
+  } else if (/\b(wordpress|wp)\b/.test(req)) targetStack = "wordpress";
+  else if (/\b(cli|command|bin)\b/.test(req)) targetStack = "cli";
+  let intent = "implementation";
+  if (/\b(document|doc|readme)\b/.test(req) || /\b(create|add|write|update|edit)\b.*\b[\w.-]+\.md\b/.test(req)) intent = "docs";
+  else if (/\b(audit|security|inspect|dependencies)\b/.test(req)) intent = "audit";
+  else if (/\b(release|publish|deploy)\b/.test(req)) intent = "release";
+  else if (/\b(prototype|standalone html)\b/.test(req)) intent = "prototype";
+  return { targetStack, intent };
+}
+var DeliveryDecisionEngine = class {
+  cwd;
+  stackDetector;
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+    this.stackDetector = new StackDetector({ cwd });
+  }
+  async determineClass(changedFiles = []) {
+    if (changedFiles.length === 0) {
+      return "empty";
+    }
+    const isDocs = changedFiles.every(
+      (file) => file.endsWith(".md") || file.endsWith(".txt") || file.startsWith("docs/")
+    );
+    if (isDocs) {
+      return "docs-only";
+    }
+    const stacks = await this.stackDetector.detect();
+    let usesJsFramework = false;
+    try {
+      const pkgPath = path2.join(this.cwd, "package.json");
+      const pkgContent = await fs2.readFile(pkgPath, "utf8");
+      const pkg = JSON.parse(pkgContent);
+      const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+      const frameworks = ["react", "next", "vue", "nuxt", "svelte", "solid-js", "preact", "quasar", "@angular/core"];
+      usesJsFramework = frameworks.some((fw) => deps[fw] !== void 0);
+    } catch {
+    }
+    const isWordPress = await checkWordPressDirectRoot(this.cwd);
+    const hasFrontendFiles = changedFiles.some(
+      (file) => /\.(html?|css|scss|sass|less|jsx|tsx|vue|svelte)$/i.test(file) || /\.js$/i.test(file) && !file.includes("config") && !file.includes("test")
+    );
+    if (isWordPress) {
+      return "wordpress-php";
+    }
+    if (usesJsFramework && hasFrontendFiles) {
+      return "framework-native-frontend";
+    }
+    if (hasFrontendFiles) {
+      return "standalone-web";
+    }
+    if (stacks.includes("python") || stacks.includes("php") || stacks.includes("node") && !usesJsFramework) {
+      return "backend-service";
+    }
+    return "generic-code";
+  }
+  async detectContext() {
+    const stacks = await this.stackDetector.detect();
+    let usesJsFramework = null;
+    let hasPackageJson = false;
+    let isCli = false;
+    try {
+      const pkgPath = path2.join(this.cwd, "package.json");
+      const pkgContent = await fs2.readFile(pkgPath, "utf8");
+      hasPackageJson = true;
+      const pkg = JSON.parse(pkgContent);
+      const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+      if (pkg.bin || pkg.name === "@williambeto/ai-workflow") {
+        isCli = true;
+      }
+      const frameworks = ["react", "next", "vue", "nuxt", "svelte", "solid-js", "preact", "quasar", "@angular/core"];
+      for (const fw of frameworks) {
+        if (deps[fw] !== void 0) {
+          usesJsFramework = fw;
+          break;
+        }
+      }
+    } catch {
+    }
+    let isLaravel = false;
+    let hasComposerJson = false;
+    try {
+      const composerPath = path2.join(this.cwd, "composer.json");
+      const composerContent = await fs2.readFile(composerPath, "utf8");
+      hasComposerJson = true;
+      const composer = JSON.parse(composerContent);
+      const reqs = { ...composer.require || {}, ...composer.requireDev || {} };
+      if (reqs["laravel/framework"]) {
+        isLaravel = true;
+      }
+    } catch {
+    }
+    const isWordPress = await checkWordPressDirectRoot(this.cwd);
+    let isEmpty = true;
+    try {
+      const entries = await fs2.readdir(this.cwd);
+      const meaningful = entries.filter((e) => !e.startsWith(".") && !["node_modules", "EVIDENCE.json"].includes(e));
+      if (meaningful.length > 0) {
+        if (meaningful.length === 1 && meaningful[0] === "package.json") {
+          try {
+            const content = await fs2.readFile(path2.join(this.cwd, "package.json"), "utf8");
+            const pkg = JSON.parse(content);
+            if (!pkg.dependencies && !pkg.devDependencies) {
+              isEmpty = true;
+            } else {
+              isEmpty = false;
+            }
+          } catch {
+            isEmpty = true;
+          }
+        } else {
+          isEmpty = false;
+        }
+      }
+    } catch {
+      isEmpty = true;
+    }
+    let projectState = isEmpty ? "empty" : "active";
+    let detectedStackType = "unknown";
+    let detectedStacks = [];
+    if (isWordPress) {
+      detectedStackType = "WordPress context";
+      detectedStacks.push("wordpress");
+    } else if (isLaravel) {
+      detectedStackType = "backend context";
+      detectedStacks.push("laravel");
+    } else if (usesJsFramework) {
+      detectedStackType = "existing matching stack";
+      detectedStacks.push(usesJsFramework);
+    } else if (isCli) {
+      detectedStackType = "CLI package context";
+      detectedStacks.push("node");
+    } else if (stacks.includes("node")) {
+      detectedStackType = "existing matching stack";
+      detectedStacks.push("node");
+    } else if (stacks.includes("python") || stacks.includes("php")) {
+      detectedStackType = "backend context";
+      detectedStacks.push(...stacks);
+    } else if (projectState === "empty") {
+      detectedStackType = "empty project";
+    }
+    return {
+      projectState,
+      detectedStackType,
+      detectedStacks,
+      isWordPress,
+      isLaravel,
+      usesJsFramework,
+      isCli
+    };
+  }
+  async determineDecision(input = {}) {
+    const userRequest = input.userRequest || "";
+    const explicitApprovals = input.explicitApprovals || [];
+    const ctx = input.projectContext || await this.detectContext();
+    const projectState = ctx.projectState || "active";
+    const detectedStacks = ctx.detectedStacks || [];
+    const isWordPress = ctx.isWordPress || false;
+    const isLaravel = ctx.isLaravel || false;
+    const isCli = ctx.isCli || false;
+    const usesJsFramework = ctx.usesJsFramework || null;
+    const parsed = parseRequest(userRequest);
+    const targetStack = parsed.targetStack;
+    const intent = parsed.intent;
+    let decision = "IMPLEMENT_IN_EXISTING_CONTEXT";
+    let allowedArtifactShape = "generic-code";
+    let forbiddenSubstitutes = ["success-without-validation"];
+    let validationRequired = ["build-or-equivalent"];
+    let approvalRequired = false;
+    if (intent === "audit") {
+      decision = "READ_ONLY_AUDIT";
+      allowedArtifactShape = "audit-report";
+      forbiddenSubstitutes.push("any-code-mutation");
+      validationRequired = [];
+    } else if (intent === "docs") {
+      decision = "DOCS_ONLY";
+      allowedArtifactShape = "markdown";
+      forbiddenSubstitutes.push("unjustified-code-mutation");
+      validationRequired = [];
+    } else if (intent === "release") {
+      decision = "RELEASE_OR_DEPLOY_REQUIRES_APPROVAL";
+      allowedArtifactShape = "package-tarball";
+      forbiddenSubstitutes.push("publish-without-approval");
+      validationRequired = ["release-readiness-or-equivalent"];
+      const hasApproval = explicitApprovals.includes("npm-publish") || explicitApprovals.includes("deploy-production");
+      if (hasApproval) {
+        decision = "RELEASE_OR_DEPLOY_APPROVED";
+        approvalRequired = true;
+      }
+    } else if (intent === "prototype") {
+      decision = "CREATE_STANDALONE_PROTOTYPE";
+      allowedArtifactShape = "standalone-html";
+      validationRequired = [];
+    } else if (projectState === "empty") {
+      decision = "SCAFFOLD_AND_IMPLEMENT";
+      if (targetStack === "vue" || targetStack === "react") {
+        allowedArtifactShape = "runnable-framework-app";
+        forbiddenSubstitutes.push("standalone-html-as-framework-delivery", "loose-framework-files-without-runtime");
+        validationRequired.push("dependency-install-or-verification", "runtime-smoke-or-equivalent");
+      }
+    } else {
+      const hasConflict = targetStack === "vue" && detectedStacks.includes("react") || targetStack === "react" && detectedStacks.includes("vue") || targetStack === "laravel" && !detectedStacks.includes("laravel") && detectedStacks.length > 0 || targetStack === "wordpress" && !detectedStacks.includes("wordpress") && detectedStacks.length > 0;
+      if (hasConflict) {
+        decision = "BLOCK_STACK_CONFLICT";
+      } else if (targetStack === "laravel" && !detectedStacks.includes("laravel")) {
+        decision = "BLOCK_UNSUPPORTED_CONTEXT";
+      } else if (targetStack === "wordpress" && !detectedStacks.includes("wordpress")) {
+        decision = "BLOCK_UNSUPPORTED_CONTEXT";
+      } else {
+        if (targetStack === "vue" || targetStack === "react") {
+          decision = "IMPLEMENT_IN_EXISTING_CONTEXT";
+          allowedArtifactShape = "runnable-framework-app";
+          forbiddenSubstitutes.push("standalone-html-as-framework-delivery", "loose-framework-files-without-runtime");
+          validationRequired.push("dependency-install-or-verification", "runtime-smoke-or-equivalent");
+        } else if (targetStack === "cli" || isCli) {
+          decision = "CLI_COMMAND_INTEGRATION";
+          allowedArtifactShape = "bin-entry";
+        }
+      }
+    }
+    if (userRequest && userRequest.trim().length < 3) {
+      decision = "BLOCK_UNCLEAR_SCOPE";
+    }
+    return {
+      intent: intent === "implementation" ? "implementation" : intent,
+      requestedOutcome: targetStack === "vue" || targetStack === "react" ? "page" : targetStack === "wordpress" ? "plugin-or-theme" : null,
+      requestedStack: targetStack,
+      requestedPlatform: targetStack === "wordpress" ? "wordpress" : null,
+      projectState,
+      detectedStacks,
+      decision,
+      allowedArtifactShape,
+      forbiddenSubstitutes,
+      validationRequired,
+      approvalRequired: explicitApprovals.length > 0
+    };
+  }
+};
+async function checkWordPressDirectRoot(cwd) {
+  const hasWpConfig = await fs2.access(path2.join(cwd, "wp-config.php")).then(() => true).catch(() => false);
+  const hasWpContent = await fs2.access(path2.join(cwd, "wp-content")).then(() => true).catch(() => false);
+  if (hasWpConfig || hasWpContent) {
+    return true;
+  }
+  const hasStyleCss = await fs2.access(path2.join(cwd, "style.css")).then(() => true).catch(() => false);
+  if (hasStyleCss) {
+    try {
+      const content = await fs2.readFile(path2.join(cwd, "style.css"), "utf8");
+      if (/\bTheme Name\s*:/i.test(content) || /\bTheme URI\s*:/i.test(content)) {
+        const otherIndicators = [
+          "functions.php",
+          "theme.json",
+          "index.php",
+          "front-page.php",
+          "single.php",
+          "page.php",
+          "archive.php",
+          "template-parts"
+        ];
+        for (const ind of otherIndicators) {
+          const exists = await fs2.access(path2.join(cwd, ind)).then(() => true).catch(() => false);
+          if (exists) {
+            return true;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const files = await fs2.readdir(cwd);
+    for (const file of files) {
+      if (file.endsWith(".php")) {
+        const content = await fs2.readFile(path2.join(cwd, file), "utf8");
+        if (/\bPlugin Name\s*:/i.test(content)) {
+          return true;
+        }
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/core/validation/artifact-fidelity-gate.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+var ArtifactFidelityGate = class {
+  cwd;
+  deliveryClass;
+  userRequest;
+  explicitApprovals;
+  deliveryDecision;
+  projectContext;
+  constructor({ cwd = process.cwd(), deliveryClass, userRequest, explicitApprovals = [] } = {}) {
+    this.cwd = cwd;
+    this.deliveryClass = deliveryClass;
+    this.userRequest = userRequest;
+    this.explicitApprovals = explicitApprovals;
+  }
+  async verify(changedFiles = []) {
+    if (changedFiles.length === 0) {
+      return { passed: true };
+    }
+    if (this.deliveryClass === "framework-native-frontend") {
+      for (const file of changedFiles) {
+        const ext = path3.extname(file).toLowerCase();
+        if (ext === ".html" || ext === ".htm") {
+          const basename = path3.basename(file).toLowerCase();
+          const isSpaEntry = basename === "index.html" && (file === "index.html" || file === "public/index.html" || file === "src/index.html");
+          if (!isSpaEntry) {
+            return {
+              passed: false,
+              reason: `Fidelity Violation: standalone HTML file '${file}' is not permitted in a framework-native frontend project. UI must be implemented within framework components (e.g. React/Vue/Next/Nuxt files) instead of static prototypes.`
+            };
+          }
+          try {
+            const content = await fs3.readFile(path3.join(this.cwd, file), "utf8");
+            if (content.includes("unpkg.com") || content.includes("cdnjs.cloudflare.com") || content.includes("cdn.jsdelivr.net")) {
+              if (content.includes("vue") || content.includes("react")) {
+                return {
+                  passed: false,
+                  reason: `Fidelity Violation: SPA entry point '${file}' imports framework library via CDN scripts. Framework dependencies must be installed and resolved locally via npm/package.json.`
+                };
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    if (this.deliveryClass === "wordpress-php") {
+      for (const file of changedFiles) {
+        const ext = path3.extname(file).toLowerCase();
+        if (ext === ".html" || ext === ".htm") {
+          return {
+            passed: false,
+            reason: `Fidelity Violation: standalone HTML file '${file}' is not permitted in a WordPress project. UI templates must be implemented in PHP files within theme or plugin structures.`
+          };
+        }
+      }
+    }
+    const frontendViolations = await this.verifyFrontendFidelity(changedFiles);
+    if (frontendViolations && frontendViolations.length > 0) {
+      return {
+        passed: false,
+        reason: frontendViolations.join("; ")
+      };
+    }
+    return { passed: true };
+  }
+  async verifyRequestFidelity(arg) {
+    let userRequest = this.userRequest || "";
+    let deliveryDecision = this.deliveryDecision || {};
+    let projectContext = this.projectContext || {};
+    let changedFiles = [];
+    let explicitApprovals = this.explicitApprovals || [];
+    if (Array.isArray(arg)) {
+      changedFiles = arg;
+    } else if (arg && typeof arg === "object") {
+      userRequest = arg.userRequest || userRequest;
+      deliveryDecision = arg.deliveryDecision || deliveryDecision;
+      projectContext = arg.projectContext || projectContext;
+      changedFiles = arg.changedFiles || changedFiles;
+      explicitApprovals = arg.explicitApprovals || explicitApprovals;
+    }
+    const blockingDecisions = /* @__PURE__ */ new Set([
+      "BLOCK_STACK_CONFLICT",
+      "BLOCK_UNCLEAR_SCOPE",
+      "BLOCK_UNSUPPORTED_CONTEXT",
+      "REQUIRE_EXPLICIT_AUTHORIZATION",
+      "RELEASE_OR_DEPLOY_REQUIRES_APPROVAL"
+    ]);
+    if (blockingDecisions.has(deliveryDecision?.decision)) {
+      const filtered = changedFiles.filter(
+        (file) => !file.startsWith(".ai-workflow/") && !file.startsWith(".git/") && file !== "EVIDENCE.json" && file !== "EVIDENCE.temp.json"
+      );
+      return {
+        status: "BLOCKED",
+        passed: false,
+        reason: `Delivery decision is blocking: ${deliveryDecision.decision}`,
+        decision: deliveryDecision.decision,
+        checkedFiles: filtered,
+        violations: [`Blocking delivery decision: ${deliveryDecision.decision}`]
+      };
+    }
+    const filteredFiles = changedFiles.filter(
+      (file) => !file.startsWith(".ai-workflow/") && !file.startsWith(".git/") && file !== "EVIDENCE.json" && file !== "EVIDENCE.temp.json"
+    );
+    const req = userRequest.toLowerCase();
+    const isReadOnly = /(inspect|audit|read-only|dependencies)/.test(req);
+    const isDocsOnly = /(document|doc|readme)/.test(req) && !req.includes("code");
+    const isRelease = /(release|publish|deploy)/.test(req);
+    const violations = [];
+    if (isReadOnly && filteredFiles.length > 0) {
+      violations.push("Read-only audit task mutated repository files mismatch.");
+    }
+    if (isDocsOnly) {
+      const codeChanged = filteredFiles.some(
+        (file) => !file.endsWith(".md") && !file.endsWith(".txt") && !file.startsWith("docs/")
+      );
+      if (codeChanged) {
+        violations.push("Documentation-only task mutated codebase files without justification mismatch.");
+      }
+    }
+    if (isRelease) {
+      const approved = explicitApprovals.includes("npm-publish") || explicitApprovals.includes("deploy-production");
+      if (!approved) {
+        violations.push("Release/deploy task proceeds without explicit approval token mismatch.");
+      }
+    }
+    const reqReact = /(react|next)/.test(req);
+    const reqVue = /(vue|nuxt)/.test(req);
+    const reqBackend = /(laravel|django|rails|express|nest|fastify|flask)/.test(req);
+    const reqWp = /(wordpress|wp)/.test(req);
+    const reqCli = /(cli|command)/.test(req);
+    if (reqReact && this.deliveryClass === "standalone-web" && !/prototype/.test(req)) {
+      violations.push("React framework page requested, but a standalone HTML/CSS substitute mismatch was delivered instead.");
+    }
+    if (reqVue && this.deliveryClass === "standalone-web" && !/prototype/.test(req)) {
+      violations.push("Vue framework page requested, but a standalone HTML/CSS substitute mismatch was delivered instead.");
+    }
+    if (reqBackend && filteredFiles.length > 0) {
+      const isLaravel = /\blaravel\b/i.test(req);
+      const isDjango = /\bdjango\b/i.test(req);
+      const isExpressNestFastify = /\b(express|nest|fastify)\b/i.test(req);
+      const isRails = /\brails\b/i.test(req);
+      if (isLaravel) {
+        const isLaravelArtifact = filteredFiles.some(
+          (file) => file === "composer.json" || file === "artisan" || file.startsWith("routes/") || file.startsWith("app/Http/Controllers/") || file.startsWith("app/Models/") || file.startsWith("app/Services/") || file.startsWith("tests/Feature/") || file.startsWith("tests/Unit/") || /(^|\/)(routes\/.*\.php|app\/Http\/Controllers\/.*\.php|app\/Models\/.*\.php|app\/Services\/.*\.php|tests\/Feature\/.*\.php|tests\/Unit\/.*\.php|artisan|composer\.json)$/.test(file)
+        );
+        if (!isLaravelArtifact) {
+          violations.push("Laravel endpoint/scaffold requested, but no valid Laravel files/structure mismatch was delivered.");
+        }
+      } else if (isDjango) {
+        const isDjangoArtifact = filteredFiles.some(
+          (file) => file === "manage.py" || file === "requirements.txt" || file === "pyproject.toml" || file.endsWith("settings.py") || file.endsWith("urls.py") || file.endsWith("views.py") || file.endsWith("models.py") || file.endsWith("tests.py") || /(^|\/)(manage\.py|settings\.py|urls\.py|views\.py|models\.py|tests\.py|requirements\.txt|pyproject\.toml)$/.test(file)
+        );
+        if (!isDjangoArtifact) {
+          violations.push("Django backend requested, but no valid Django files/structure mismatch was delivered.");
+        }
+      } else if (isExpressNestFastify) {
+        const isExpressNestFastifyArtifact = filteredFiles.some(
+          (file) => file === "package.json" || file.startsWith("src/routes/") || file.startsWith("src/controllers/") || file.startsWith("src/services/") || file.startsWith("tests/") || /(^|\/)(package\.json|src\/routes\/.*|src\/controllers\/.*|src\/services\/.*|tests\/.*|server\.[a-z]+|app\.[a-z]+|main\.[a-z]+)$/.test(file)
+        );
+        if (!isExpressNestFastifyArtifact) {
+          violations.push("Express/Fastify/Nest backend requested, but no valid Node.js server files/structure mismatch was delivered.");
+        }
+      } else if (isRails) {
+        const isRailsArtifact = filteredFiles.some(
+          (file) => file === "Gemfile" || file === "config/routes.rb" || file.startsWith("app/controllers/") || file.startsWith("app/models/") || file.startsWith("app/services/") || file.startsWith("test/") || file.startsWith("spec/") || /(^|\/)(Gemfile|config\/routes\.rb|app\/controllers\/.*|app\/models\/.*|app\/services\/.*|test\/.*|spec\/.*)$/.test(file)
+        );
+        if (!isRailsArtifact) {
+          violations.push("Ruby on Rails backend requested, but no valid Rails files/structure mismatch was delivered.");
+        }
+      } else {
+        const isGenericBackendArtifact = filteredFiles.some(
+          (file) => !file.includes("plain_script.py") && (file.startsWith("app/") || file.startsWith("routes/") || file.startsWith("config/") || file.startsWith("src/controllers/") || file.startsWith("src/routes/") || file.startsWith("src/services/") || file.startsWith("backend/") || file.startsWith("server/") || file.startsWith("api/") || file.endsWith(".py") || file.endsWith(".php") || file.endsWith(".rb") || file.endsWith(".go"))
+        );
+        if (!isGenericBackendArtifact) {
+          violations.push("Backend endpoint requested, but wrong backend artifact structure mismatch was delivered.");
+        }
+      }
+    }
+    if (reqCli && filteredFiles.length > 0) {
+      const isCliArtifact = filteredFiles.some(
+        (file) => file.startsWith("bin/") || file.startsWith("src/commands/")
+      );
+      if (!isCliArtifact) {
+        violations.push("CLI command requested, but a loose script outside the executable bin/commands configuration mismatch was delivered.");
+      }
+    }
+    if (reqWp && filteredFiles.length > 0) {
+      let isWpArtifact = false;
+      for (const file of filteredFiles) {
+        const basename = path3.basename(file);
+        const ext = path3.extname(file).toLowerCase();
+        if (file.startsWith("wp-content/") || file === "wp-config.php") {
+          isWpArtifact = true;
+          break;
+        }
+        if (basename === "functions.php" || basename === "front-page.php" || basename === "single.php" || basename === "page.php" || basename === "archive.php" || basename === "theme.json" || file.startsWith("template-parts/") || file.includes("/template-parts/")) {
+          isWpArtifact = true;
+          break;
+        }
+        if (basename === "style.css") {
+          const hasHeader = await hasWpThemeHeader(this.cwd, file);
+          if (hasHeader) {
+            isWpArtifact = true;
+            break;
+          }
+        }
+        if (basename === "index.php") {
+          isWpArtifact = true;
+          break;
+        }
+        if (basename === "uninstall.php" || basename === "composer.json" || file.startsWith("includes/") || file.includes("/includes/") || file.startsWith("admin/") || file.includes("/admin/") || file.startsWith("public/") || file.includes("/public/") || file.startsWith("src/") || file.includes("/src/")) {
+          isWpArtifact = true;
+          break;
+        }
+        if (ext === ".php") {
+          const hasHeader = await hasWpPluginHeader(this.cwd, file);
+          if (hasHeader) {
+            isWpArtifact = true;
+            break;
+          }
+        }
+      }
+      const hasHtml = filteredFiles.some((file) => path3.extname(file).toLowerCase() === ".html" || path3.extname(file).toLowerCase() === ".htm");
+      if (!isWpArtifact || hasHtml) {
+        violations.push("WordPress plugin or theme requested, but files were delivered outside the WordPress structure or contained standalone HTML.");
+      }
+    }
+    const frontendViolations = await this.verifyFrontendFidelity(filteredFiles);
+    if (frontendViolations && frontendViolations.length > 0) {
+      violations.push(...frontendViolations);
+    }
+    const status = violations.length > 0 ? "BLOCKED" : "PASS";
+    return {
+      status,
+      passed: status === "PASS",
+      reason: violations.length > 0 ? `Fidelity violations: ${violations.join("; ")}` : "Verification passed",
+      decision: deliveryDecision.decision || this.deliveryClass,
+      checkedFiles: filteredFiles,
+      violations
+    };
+  }
+  async verifyFrontendFidelity(changedFiles) {
+    const skillPaths = [
+      path3.join(this.cwd, ".agents/skills/frontend-design-system/SKILL.md"),
+      path3.join(this.cwd, ".agents/skills/frontend_design_system/SKILL.md"),
+      path3.join(this.cwd, ".ai-workflow/opencode/skills/frontend-design-system/SKILL.md"),
+      path3.join(this.cwd, ".ai-workflow/opencode/skills/frontend_design_system/SKILL.md"),
+      path3.join(this.cwd, "opencode/skills/frontend-design-system/SKILL.md"),
+      path3.join(this.cwd, "opencode/skills/frontend_design_system/SKILL.md")
+    ];
+    let hasDesignSystemSkill = false;
+    for (const p of skillPaths) {
+      const exists = await fs3.access(p).then(() => true).catch(() => false);
+      if (exists) {
+        hasDesignSystemSkill = true;
+        break;
+      }
+    }
+    if (!hasDesignSystemSkill) {
+      return null;
+    }
+    const uiFiles = changedFiles.filter(
+      (file) => /\.(tsx|jsx|vue|html|css|scss|less|blade\.php)$/.test(file)
+    );
+    if (uiFiles.length === 0) return null;
+    const violations = [];
+    let cssContentCombined = "";
+    let htmlContentCombined = "";
+    let styleAttrsCount = 0;
+    for (const file of uiFiles) {
+      try {
+        const fullPath = path3.join(this.cwd, file);
+        const content = await fs3.readFile(fullPath, "utf8");
+        if (/\.(css|scss|less|vue|tsx|jsx)$/.test(file)) {
+          cssContentCombined += content;
+        }
+        if (/\.(html|vue|tsx|jsx|blade\.php)$/.test(file)) {
+          htmlContentCombined += content;
+          const inlineStyles = content.match(/style\s*=\s*["']/g) || [];
+          styleAttrsCount += inlineStyles.length;
+          if (/(unpkg\.com|cdnjs\.cloudflare\.com|cdn\.jsdelivr\.net|tailwindcss|bootstrap)/i.test(content)) {
+            const isApproved = (this.explicitApprovals || []).some(
+              (app) => /cdn-styles|tailwind|bootstrap/i.test(app)
+            );
+            if (!isApproved) {
+              violations.push(`Fidelity Violation: standalone external CDN style/library dependency detected in '${file}' without explicit authorization.`);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const hasRules = cssContentCombined.includes("{");
+    const cssVarsApproved = (this.explicitApprovals || []).some(
+      (app) => /no-css-vars|css-vars-bypass/i.test(app)
+    );
+    const cssRulesContent = cssContentCombined.replace(/\/\*[\s\S]*?\*\//g, "").trim();
+    const isSubstantialCss = cssRulesContent.length > 200;
+    const hasCssVars = /(--[a-zA-Z0-9_-]+\s*:|var\(--[a-zA-Z0-9_-]+\))/g.test(cssContentCombined);
+    if (hasRules && isSubstantialCss && !hasCssVars && !cssVarsApproved) {
+      violations.push("Fidelity Violation: Design System token mismatch. No CSS custom properties (variables) detected or used in changed UI stylesheets. Add explicit approval 'no-css-vars' to bypass this check for simple or legacy stylesheets.");
+    }
+    if (styleAttrsCount > 5) {
+      violations.push(`Fidelity Violation: excessive inline styles detected (${styleAttrsCount} style="..." declarations). Use CSS classes or utility classes instead.`);
+    }
+    if (htmlContentCombined.length > 0) {
+      const hasSemanticTags = /<(header|main|footer|nav|section)\b/i.test(htmlContentCombined);
+      const hasH1 = /<h1\b/i.test(htmlContentCombined);
+      if (!hasSemanticTags && !hasH1) {
+        violations.push("Fidelity Violation: HTML layout structure lacks basic semantic elements (<header>, <main>, <footer>, <nav>, <section>) or <h1> tag.");
+      }
+    }
+    return violations;
+  }
+};
+async function hasWpThemeHeader(cwd, file) {
+  try {
+    const fullPath = path3.join(cwd, file);
+    const content = await fs3.readFile(fullPath, "utf8");
+    return /\bTheme Name\s*:/i.test(content) || /\bTheme URI\s*:/i.test(content);
+  } catch {
+    return false;
+  }
+}
+async function hasWpPluginHeader(cwd, file) {
+  try {
+    const fullPath = path3.join(cwd, file);
+    const content = await fs3.readFile(fullPath, "utf8");
+    return /\bPlugin Name\s*:/i.test(content) || /\bDescription\s*:/i.test(content);
+  } catch {
+    return false;
+  }
+}
+
+export {
+  MergeGate,
+  StackDetector,
+  DeliveryDecisionEngine,
+  ArtifactFidelityGate
+};
+//# sourceMappingURL=chunk-2AOV2ATY.js.map