@codexa/cli 9.0.7 → 9.0.8

package/gates/standards-validator.ts

@@ -1,8 +1,13 @@
 import { getDb } from "../db/connection";
 import { existsSync, readFileSync } from "fs";
-import { basename, extname } from "path";
+import { basename, resolve } from "path";
+import { isGrepaiAvailable, searchWithGrepai, type GrepaiResult } from "../commands/patterns";
 
-interface Violation {
+// ═══════════════════════════════════════════════════════════════
+// INTERFACES
+// ═══════════════════════════════════════════════════════════════
+
+export interface Violation {
   file: string;
   rule: string;
   category: string;
@@ -10,12 +15,36 @@ interface Violation {
   detail?: string;
 }
 
-interface ValidationResult {
+export interface ValidationResult {
   passed: boolean;
   violations: Violation[];
   warnings: Violation[];
 }
 
+interface StandardRow {
+  id: number;
+  category: string;
+  scope: string;
+  rule: string;
+  examples: string | null;
+  anti_examples: string | null;
+  enforcement: string;
+  source: string | null;
+  semantic_query: string | null;
+  expect: string;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// CONSTANTES
+// ═══════════════════════════════════════════════════════════════
+
+const SEMANTIC_SCORE_THRESHOLD = 0.7;
+const MAX_SEMANTIC_QUERIES = 10;
+
+// ═══════════════════════════════════════════════════════════════
+// VALIDACAO PRINCIPAL
+// ═══════════════════════════════════════════════════════════════
+
 export function validateAgainstStandards(
   files: string[],
   agentDomain: string
@@ -24,19 +53,112 @@ export function validateAgainstStandards(
   const violations: Violation[] = [];
   const warnings: Violation[] = [];
 
-  // Buscar standards aplicáveis
   const standards = db
     .query(
       `SELECT * FROM standards
        WHERE (scope = 'all' OR scope = ?)
        ORDER BY enforcement DESC, category`
     )
-    .all(agentDomain) as any[];
+    .all(agentDomain) as StandardRow[];
 
   if (standards.length === 0) {
     return { passed: true, violations: [], warnings: [] };
   }
 
+  // Separar standards semanticos dos textuais
+  const semanticStandards = standards
+    .filter(s => s.semantic_query && s.semantic_query.trim().length > 0)
+    .slice(0, MAX_SEMANTIC_QUERIES);
+  const textualStandards = standards.filter(
+    s => !s.semantic_query || s.semantic_query.trim().length === 0
+  );
+
+  // Normalizar paths dos arquivos sendo validados
+  const normalizedFiles = new Set(
+    files.filter(f => existsSync(f)).map(f => resolve(f).replace(/\\/g, "/"))
+  );
+
+  // === MODO 1: Validacao semantica via grepai ===
+  if (semanticStandards.length > 0) {
+    if (isGrepaiAvailable()) {
+      validateSemantic(semanticStandards, normalizedFiles, files, violations, warnings);
+    } else {
+      // Fallback: apenas no_match com anti_examples
+      const fallbackStandards = semanticStandards.filter(s => s.expect === "no_match");
+      const skipped = semanticStandards.length - fallbackStandards.length;
+      if (skipped > 0) {
+        console.warn(`[standards] grepai nao disponivel. ${skipped} standard(s) must_match ignorado(s).`);
+      }
+      if (fallbackStandards.length > 0) {
+        console.warn("[standards] grepai nao disponivel. Usando fallback textual para standards semanticos.");
+        validateTextual(fallbackStandards, files, violations, warnings);
+      }
+    }
+  }
+
+  // === MODO 2: Validacao textual (anti_examples) ===
+  if (textualStandards.length > 0) {
+    validateTextual(textualStandards, files, violations, warnings);
+  }
+
+  return {
+    passed: violations.length === 0,
+    violations,
+    warnings,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// VALIDACAO SEMANTICA (grepai)
+// ═══════════════════════════════════════════════════════════════
+
+function validateSemantic(
+  standards: StandardRow[],
+  normalizedFiles: Set<string>,
+  originalFiles: string[],
+  violations: Violation[],
+  warnings: Violation[]
+): void {
+  for (const std of standards) {
+    if (!std.semantic_query) continue;
+
+    const results = searchWithGrepai(std.semantic_query, 20);
+
+    // Filtrar: apenas arquivos sendo validados + score acima do threshold
+    const matchingFiles = results.filter(r => {
+      const normalized = resolve(r.path).replace(/\\/g, "/");
+      return normalizedFiles.has(normalized) && r.score >= SEMANTIC_SCORE_THRESHOLD;
+    });
+
+    const hasMatch = matchingFiles.length > 0;
+
+    if (std.expect === "no_match" && hasMatch) {
+      for (const match of matchingFiles) {
+        addViolation(std, match.path,
+          `Violacao semantica (score: ${match.score.toFixed(2)}): "${std.semantic_query}"`,
+          violations, warnings);
+      }
+    } else if (std.expect === "must_match" && !hasMatch) {
+      for (const file of originalFiles) {
+        if (!existsSync(file)) continue;
+        addViolation(std, file,
+          `Padrao obrigatorio nao encontrado: "${std.semantic_query}"`,
+          violations, warnings);
+      }
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// VALIDACAO TEXTUAL (anti_examples fallback)
+// ═══════════════════════════════════════════════════════════════
+
+function validateTextual(
+  standards: StandardRow[],
+  files: string[],
+  violations: Violation[],
+  warnings: Violation[]
+): void {
   for (const file of files) {
     if (!existsSync(file)) continue;
 
@@ -47,135 +169,52 @@ export function validateAgainstStandards(
       continue;
     }
 
-    const fileName = basename(file);
-    const ext = extname(file);
-
     for (const std of standards) {
-      let violated = false;
-      let detail: string | undefined;
-
-      // Validações por categoria
-      switch (std.category) {
-        case "naming":
-          // Validar PascalCase para componentes React/Next
-          if (std.rule.toLowerCase().includes("pascalcase") && (ext === ".tsx" || ext === ".jsx")) {
-            const nameWithoutExt = fileName.replace(ext, "");
-            // Ignorar arquivos especiais (page, layout, loading, etc.)
-            const specialFiles = ["page", "layout", "loading", "error", "not-found", "template", "default"];
-            if (!specialFiles.includes(nameWithoutExt)) {
-              violated = !/^[A-Z][a-zA-Z0-9]*$/.test(nameWithoutExt);
-              if (violated) {
-                detail = `"${fileName}" deveria ser PascalCase (ex: ${nameWithoutExt.charAt(0).toUpperCase() + nameWithoutExt.slice(1)}.tsx)`;
-              }
-            }
-          }
-
-          // Validar camelCase para hooks
-          if (std.rule.toLowerCase().includes("use") && std.rule.toLowerCase().includes("hook")) {
-            if (fileName.includes("use") || fileName.includes("Use")) {
-              violated = !/^use[A-Z][a-zA-Z0-9]*\.ts$/.test(fileName);
-              if (violated) {
-                detail = `Hook "${fileName}" deveria seguir padrao useXxx.ts`;
-              }
-            }
-          }
-          break;
-
-        case "code":
-          // Validar Server Components (sem "use client" desnecessário)
-          if (std.rule.toLowerCase().includes("server component")) {
-            // Se está em app/ e não é um componente interativo, não deveria ter "use client"
-            if (file.includes("/app/") && !file.includes("/components/")) {
-              const hasUseClient = content.includes('"use client"') || content.includes("'use client'");
-              const hasInteractiveCode =
-                content.includes("useState") ||
-                content.includes("useEffect") ||
-                content.includes("onClick") ||
-                content.includes("onChange");
-
-              if (hasUseClient && !hasInteractiveCode) {
-                violated = true;
-                detail = `Arquivo tem "use client" mas nao usa hooks ou eventos interativos`;
-              }
-            }
-          }
-
-          // Validar uso de @ alias
-          if (std.rule.toLowerCase().includes("@") && std.rule.toLowerCase().includes("alias")) {
-            // Verificar imports relativos profundos
-            const deepRelativeImport = /from ['"]\.\.\/\.\.\/\.\.\//;
-            if (deepRelativeImport.test(content)) {
-              violated = true;
-              detail = `Imports relativos profundos (../../..) deveriam usar @ alias`;
-            }
-          }
-          break;
-
-        case "structure":
-          // Validar pasta de componentes
-          if (std.rule.toLowerCase().includes("component") && (ext === ".tsx" || ext === ".jsx")) {
-            const isComponent = /^[A-Z]/.test(fileName) && !file.includes("/app/");
-            if (isComponent && !file.includes("/components/")) {
-              violated = true;
-              detail = `Componente "${fileName}" deveria estar em /components/`;
-            }
-          }
-          break;
+      if (!std.anti_examples) continue;
 
-        case "library":
-          // Validar anti-exemplos (bibliotecas proibidas)
-          const antiExamples = std.anti_examples ? JSON.parse(std.anti_examples) : [];
-          for (const anti of antiExamples) {
-            if (content.includes(anti)) {
-              violated = true;
-              detail = `Uso de "${anti}" nao permitido. ${std.rule}`;
-              break;
-            }
-          }
-          break;
-
-        case "practice":
-          // Validar práticas obrigatórias
-          if (std.rule.toLowerCase().includes("zod") && std.rule.toLowerCase().includes("valid")) {
-            // Se arquivo define tipos/interfaces com Props, deveria usar Zod
-            const hasPropsInterface = /interface\s+\w*Props\b/.test(content);
-            const hasPropsType = /type\s+\w*Props\s*=/.test(content);
-            const usesZod = content.includes("z.") || content.includes("from 'zod'") || content.includes('from "zod"');
-
-            if ((hasPropsInterface || hasPropsType) && !usesZod && file.includes("/components/")) {
-              // Isso é mais um warning do que violation
-              if (std.enforcement === "required") {
-                violated = true;
-                detail = `Componente define Props mas nao usa Zod para validacao`;
-              }
-            }
-          }
-          break;
+      let antiExamples: string[];
+      try {
+        antiExamples = JSON.parse(std.anti_examples);
+      } catch {
+        continue;
       }
 
-      if (violated) {
-        const violation: Violation = {
-          file,
-          rule: std.rule,
-          category: std.category,
-          enforcement: std.enforcement,
-          detail,
-        };
-
-        if (std.enforcement === "required") {
-          violations.push(violation);
-        } else {
-          warnings.push(violation);
+      for (const anti of antiExamples) {
+        if (content.includes(anti)) {
+          addViolation(std, file,
+            `Uso de "${anti}" viola standard: ${std.rule}`,
+            violations, warnings);
+          break;
         }
       }
     }
   }
+}
 
-  return {
-    passed: violations.length === 0,
-    violations,
-    warnings,
+// ═══════════════════════════════════════════════════════════════
+// HELPERS
+// ═══════════════════════════════════════════════════════════════
+
+function addViolation(
+  std: StandardRow,
+  file: string,
+  detail: string,
+  violations: Violation[],
+  warnings: Violation[]
+): void {
+  const violation: Violation = {
+    file,
+    rule: std.rule,
+    category: std.category,
+    enforcement: std.enforcement,
+    detail,
   };
+
+  if (std.enforcement === "required") {
+    violations.push(violation);
+  } else {
+    warnings.push(violation);
+  }
 }
 
 export function printValidationResult(result: ValidationResult): void {
@@ -202,4 +241,4 @@ export function printValidationResult(result: ValidationResult): void {
       console.warn();
     }
   }
-}
+}