@williambeto/ai-workflow 2.3.6 → 2.4.0

package/src/core/validation/artifact-fidelity-gate.js

@@ -2,9 +2,11 @@ import fs from "node:fs/promises";
 import path from "node:path";
 
 export class ArtifactFidelityGate {
-  constructor({ cwd = process.cwd(), deliveryClass } = {}) {
+  constructor({ cwd = process.cwd(), deliveryClass, userRequest, explicitApprovals } = {}) {
     this.cwd = cwd;
     this.deliveryClass = deliveryClass;
+    this.userRequest = userRequest;
+    this.explicitApprovals = explicitApprovals;
   }
 
   async verify(changedFiles = []) {
@@ -16,7 +18,6 @@ export class ArtifactFidelityGate {
       for (const file of changedFiles) {
         const ext = path.extname(file).toLowerCase();
         
-        // 1. Forbid adding/modifying HTML files that are not SPA entry points
         if (ext === ".html" || ext === ".htm") {
           const basename = path.basename(file).toLowerCase();
           const isSpaEntry = basename === "index.html" && 
@@ -28,7 +29,6 @@ export class ArtifactFidelityGate {
             };
           }
 
-          // Check if SPA entry imports framework libraries via CDN script tags
           try {
             const content = await fs.readFile(path.join(this.cwd, file), "utf8");
             if (content.includes("unpkg.com") || content.includes("cdnjs.cloudflare.com") || content.includes("cdn.jsdelivr.net")) {
@@ -58,6 +58,367 @@ export class ArtifactFidelityGate {
       }
     }
 
+    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 = 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 = path.basename(file);
+        const ext = path.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 => path.extname(file).toLowerCase() === ".html" || path.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 dsSkillPath1 = path.join(this.cwd, ".agents/skills/frontend-design-system/SKILL.md");
+    const dsSkillPath2 = path.join(this.cwd, ".agents/skills/frontend_design_system/SKILL.md");
+    const hasDesignSystemSkill = await fs.access(dsSkillPath1).then(() => true).catch(() => false) ||
+                                 await fs.access(dsSkillPath2).then(() => true).catch(() => false);
+    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 = path.join(this.cwd, file);
+        const content = await fs.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;
+          
+          // Match inline style attributes
+          const inlineStyles = content.match(/style\s*=\s*["']/g) || [];
+          styleAttrsCount += inlineStyles.length;
+
+          // CDN Checks
+          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 {
+        // ignore
+      }
+    }
+
+    // 1. Tokens CSS mínimos Check
+    const hasRules = cssContentCombined.includes("{");
+    const hasCssVars = /--[a-zA-Z0-9_-]+\s*:/g.test(cssContentCombined);
+    if (hasRules && !hasCssVars) {
+      violations.push("Fidelity Violation: Design System token mismatch. No CSS custom properties (variables) detected in changed UI stylesheets.");
+    }
+
+    // 2. Excesso de style="..."
+    if (styleAttrsCount > 5) {
+      violations.push(`Fidelity Violation: excessive inline styles detected (${styleAttrsCount} style="..." declarations). Use CSS classes or utility classes instead.`);
+    }
+
+    // 3. HTML principal tags semânticas básicas Check
+    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 = path.join(cwd, file);
+    const content = await fs.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 = path.join(cwd, file);
+    const content = await fs.readFile(fullPath, "utf8");
+    return /\bPlugin Name\s*:/i.test(content) || /\bDescription\s*:/i.test(content);
+  } catch {
+    return false;
+  }
 }