@codexa/cli 8.5.0

package/detectors/rust.ts

@@ -0,0 +1,349 @@
+/**
+ * Rust Ecosystem Detector
+ *
+ * Detects Rust projects including:
+ * - Frameworks: Actix-web, Axum, Rocket, Warp, Tide
+ * - ORMs: Diesel, SeaORM, SQLx
+ * - Testing: built-in, proptest, criterion
+ */
+
+import { join } from "path";
+import {
+  registerDetector,
+  Detector,
+  DetectorResult,
+  DetectedTechnology,
+  fileExists,
+  dirExists,
+  findFiles,
+  readText,
+  parseToml,
+} from "./index";
+
+interface CargoToml {
+  package?: {
+    name?: string;
+    version?: string;
+    edition?: string;
+  };
+  dependencies?: Record<string, any>;
+  "dev-dependencies"?: Record<string, any>;
+  "build-dependencies"?: Record<string, any>;
+  workspace?: {
+    members?: string[];
+  };
+}
+
+function parseCargoToml(content: string): CargoToml {
+  return parseToml(content) as CargoToml;
+}
+
+const rustDetector: Detector = {
+  name: "rust",
+  ecosystem: "rust",
+  priority: 75,
+  markers: [
+    { type: "file", pattern: "Cargo.toml", weight: 1.0 },
+    { type: "file", pattern: "Cargo.lock", weight: 0.9 },
+    { type: "file", pattern: "rust-toolchain.toml", weight: 0.8 },
+    { type: "file", pattern: "rust-toolchain", weight: 0.8 },
+    { type: "glob", pattern: "**/*.rs", weight: 0.7 },
+    { type: "directory", pattern: "src", weight: 0.4 },
+    { type: "directory", pattern: "target", weight: 0.3 },
+  ],
+
+  async detect(cwd: string): Promise<DetectorResult | null> {
+    const technologies: DetectedTechnology[] = [];
+    const structure: Record<string, string> = {};
+    const configFiles: string[] = [];
+
+    // Check for Cargo.toml
+    const cargoPath = join(cwd, "Cargo.toml");
+    if (!fileExists(cargoPath)) {
+      // Check for Rust files without Cargo.toml
+      const rsFiles = findFiles(cwd, "**/*.rs");
+      if (rsFiles.length === 0) return null;
+
+      technologies.push({
+        name: "Rust",
+        confidence: 0.6,
+        source: "*.rs files (no Cargo.toml)",
+        category: "runtime",
+      });
+
+      return { ecosystem: "rust", technologies, structure, configFiles };
+    }
+
+    configFiles.push("Cargo.toml");
+    if (fileExists(join(cwd, "Cargo.lock"))) configFiles.push("Cargo.lock");
+    if (fileExists(join(cwd, "rust-toolchain.toml"))) configFiles.push("rust-toolchain.toml");
+
+    const cargoContent = readText(cargoPath);
+    if (!cargoContent) return null;
+
+    const cargo = parseCargoToml(cargoContent);
+
+    // Add Rust runtime
+    technologies.push({
+      name: "Rust",
+      version: cargo.package?.edition ? `Edition ${cargo.package.edition}` : undefined,
+      confidence: 1.0,
+      source: "Cargo.toml",
+      category: "runtime",
+    });
+
+    // Check for workspace
+    if (cargo.workspace?.members) {
+      technologies.push({
+        name: "Cargo Workspace",
+        confidence: 1.0,
+        source: "Cargo.toml [workspace]",
+        category: "build",
+      });
+    }
+
+    // Collect all dependencies
+    const allDeps = new Map<string, any>();
+    const addDeps = (deps: Record<string, any> | undefined) => {
+      if (!deps) return;
+      for (const [name, value] of Object.entries(deps)) {
+        allDeps.set(name, value);
+      }
+    };
+
+    addDeps(cargo.dependencies);
+    addDeps(cargo["dev-dependencies"]);
+    addDeps(cargo["build-dependencies"]);
+
+    // Web Framework Detection
+    const webFrameworks = [
+      { deps: ["actix-web"], name: "Actix Web", confidence: 1.0 },
+      { deps: ["axum"], name: "Axum", confidence: 1.0 },
+      { deps: ["rocket"], name: "Rocket", confidence: 1.0 },
+      { deps: ["warp"], name: "Warp", confidence: 1.0 },
+      { deps: ["tide"], name: "Tide", confidence: 1.0 },
+      { deps: ["hyper"], name: "Hyper", confidence: 0.85 },
+      { deps: ["poem"], name: "Poem", confidence: 1.0 },
+      { deps: ["salvo"], name: "Salvo", confidence: 1.0 },
+      { deps: ["ntex"], name: "Ntex", confidence: 1.0 },
+    ];
+
+    for (const fw of webFrameworks) {
+      const found = fw.deps.find(d => allDeps.has(d));
+      if (found) {
+        const depValue = allDeps.get(found);
+        const version = typeof depValue === "string" ? depValue : depValue?.version;
+        technologies.push({
+          name: fw.name,
+          version,
+          confidence: fw.confidence,
+          source: `Dependency: ${found}`,
+          category: "backend",
+        });
+      }
+    }
+
+    // ORM/Database Library Detection
+    const orms = [
+      { deps: ["diesel"], name: "Diesel", confidence: 1.0 },
+      { deps: ["sea-orm"], name: "SeaORM", confidence: 1.0 },
+      { deps: ["sqlx"], name: "SQLx", confidence: 1.0 },
+      { deps: ["rbatis"], name: "Rbatis", confidence: 1.0 },
+      { deps: ["rusqlite"], name: "rusqlite", confidence: 0.9 },
+    ];
+
+    for (const orm of orms) {
+      const found = orm.deps.find(d => allDeps.has(d));
+      if (found) {
+        const depValue = allDeps.get(found);
+        const version = typeof depValue === "string" ? depValue : depValue?.version;
+        technologies.push({
+          name: orm.name,
+          version,
+          confidence: orm.confidence,
+          source: `Dependency: ${found}`,
+          category: "orm",
+        });
+      }
+    }
+
+    // Database Drivers
+    const dbDrivers = [
+      { deps: ["tokio-postgres", "postgres"], name: "PostgreSQL", confidence: 0.9 },
+      { deps: ["mysql", "mysql_async"], name: "MySQL", confidence: 0.9 },
+      { deps: ["mongodb"], name: "MongoDB", confidence: 0.9 },
+      { deps: ["redis"], name: "Redis", confidence: 0.9 },
+      { deps: ["elasticsearch"], name: "Elasticsearch", confidence: 0.9 },
+    ];
+
+    const detectedDbs = new Set<string>();
+    for (const db of dbDrivers) {
+      const found = db.deps.find(d => allDeps.has(d));
+      if (found && !detectedDbs.has(db.name)) {
+        technologies.push({
+          name: db.name,
+          confidence: db.confidence,
+          source: `Dependency: ${found}`,
+          category: "database",
+        });
+        detectedDbs.add(db.name);
+      }
+    }
+
+    // Async Runtime
+    const asyncRuntimes = [
+      { deps: ["tokio"], name: "Tokio", confidence: 1.0 },
+      { deps: ["async-std"], name: "async-std", confidence: 1.0 },
+      { deps: ["smol"], name: "Smol", confidence: 1.0 },
+    ];
+
+    for (const runtime of asyncRuntimes) {
+      const found = runtime.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: runtime.name,
+          confidence: runtime.confidence,
+          source: `Dependency: ${found}`,
+          category: "runtime",
+          metadata: { type: "async-runtime" },
+        });
+      }
+    }
+
+    // Serialization
+    const serializationLibs = [
+      { deps: ["serde", "serde_json"], name: "Serde", confidence: 0.95 },
+    ];
+
+    for (const lib of serializationLibs) {
+      const found = lib.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: lib.name,
+          confidence: lib.confidence,
+          source: `Dependency: ${found}`,
+          category: "backend",
+          metadata: { type: "serialization" },
+        });
+      }
+    }
+
+    // Testing Tools
+    const testingTools = [
+      { deps: ["proptest"], name: "Proptest", confidence: 1.0 },
+      { deps: ["quickcheck"], name: "QuickCheck", confidence: 1.0 },
+      { deps: ["criterion"], name: "Criterion (Benchmarks)", confidence: 1.0 },
+      { deps: ["mockall"], name: "Mockall", confidence: 1.0 },
+      { deps: ["rstest"], name: "rstest", confidence: 1.0 },
+    ];
+
+    for (const test of testingTools) {
+      const found = test.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: test.name,
+          confidence: test.confidence,
+          source: `Dependency: ${found}`,
+          category: "testing",
+        });
+      }
+    }
+
+    // CLI/DevTools
+    const devTools = [
+      { deps: ["clap"], name: "Clap CLI", confidence: 0.9 },
+      { deps: ["structopt"], name: "StructOpt CLI", confidence: 0.9 },
+      { deps: ["tracing"], name: "Tracing", confidence: 0.9 },
+      { deps: ["log", "env_logger"], name: "log", confidence: 0.85 },
+      { deps: ["config"], name: "config-rs", confidence: 0.9 },
+    ];
+
+    for (const tool of devTools) {
+      const found = tool.deps.find(d => allDeps.has(d));
+      if (found) {
+        technologies.push({
+          name: tool.name,
+          confidence: tool.confidence,
+          source: `Dependency: ${found}`,
+          category: "devops",
+        });
+      }
+    }
+
+    // WASM Support
+    if (allDeps.has("wasm-bindgen") || allDeps.has("wasm-pack")) {
+      technologies.push({
+        name: "WebAssembly",
+        confidence: 1.0,
+        source: "wasm-bindgen/wasm-pack dependency",
+        category: "frontend",
+      });
+    }
+
+    // Embedded/Systems
+    if (allDeps.has("embedded-hal") || allDeps.has("cortex-m")) {
+      technologies.push({
+        name: "Embedded Systems",
+        confidence: 1.0,
+        source: "embedded-hal/cortex-m dependency",
+        category: "backend",
+        metadata: { type: "embedded" },
+      });
+    }
+
+    // Structure detection
+    const structurePaths = [
+      { key: "src", paths: ["src"] },
+      { key: "api", paths: ["src/api", "src/routes", "src/handlers"] },
+      { key: "models", paths: ["src/models", "src/domain", "src/entities"] },
+      { key: "services", paths: ["src/services", "src/service"] },
+      { key: "repository", paths: ["src/repository", "src/db", "src/repos"] },
+      { key: "config", paths: ["src/config", "config"] },
+      { key: "migrations", paths: ["migrations", "src/migrations"] },
+      { key: "tests", paths: ["tests"] },
+      { key: "benches", paths: ["benches"] },
+      { key: "examples", paths: ["examples"] },
+    ];
+
+    for (const { key, paths } of structurePaths) {
+      for (const p of paths) {
+        if (dirExists(join(cwd, p))) {
+          structure[key] = p;
+          break;
+        }
+      }
+    }
+
+    // Config files
+    const configPatterns = [
+      ".cargo/config.toml",
+      "clippy.toml",
+      ".clippy.toml",
+      "rustfmt.toml",
+      ".rustfmt.toml",
+      "deny.toml",
+      "Makefile",
+      "Makefile.toml",
+      "Dockerfile",
+      "docker-compose.yml",
+    ];
+
+    for (const pattern of configPatterns) {
+      if (fileExists(join(cwd, pattern))) {
+        configFiles.push(pattern);
+      }
+    }
+
+    return {
+      ecosystem: "rust",
+      technologies,
+      structure,
+      configFiles: [...new Set(configFiles)],
+    };
+  },
+};
+
+// Register the detector
+registerDetector(rustDetector);
+
+export default rustDetector;

package/gates/standards-validator.ts

@@ -0,0 +1,205 @@
+import { getDb } from "../db/connection";
+import { existsSync, readFileSync } from "fs";
+import { basename, extname } from "path";
+
+interface Violation {
+  file: string;
+  rule: string;
+  category: string;
+  enforcement: string;
+  detail?: string;
+}
+
+interface ValidationResult {
+  passed: boolean;
+  violations: Violation[];
+  warnings: Violation[];
+}
+
+export function validateAgainstStandards(
+  files: string[],
+  agentDomain: string
+): ValidationResult {
+  const db = getDb();
+  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[];
+
+  if (standards.length === 0) {
+    return { passed: true, violations: [], warnings: [] };
+  }
+
+  for (const file of files) {
+    if (!existsSync(file)) continue;
+
+    let content: string;
+    try {
+      content = readFileSync(file, "utf-8");
+    } catch {
+      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;
+
+        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;
+      }
+
+      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);
+        }
+      }
+    }
+  }
+
+  return {
+    passed: violations.length === 0,
+    violations,
+    warnings,
+  };
+}
+
+export function printValidationResult(result: ValidationResult): void {
+  if (result.violations.length > 0) {
+    console.error("\n⛔ VIOLACOES DE STANDARDS (required):\n");
+    for (const v of result.violations) {
+      console.error(`  [${v.category}] ${basename(v.file)}`);
+      console.error(`    Regra: ${v.rule}`);
+      if (v.detail) {
+        console.error(`    Detalhe: ${v.detail}`);
+      }
+      console.error();
+    }
+  }
+
+  if (result.warnings.length > 0) {
+    console.warn("\n⚠ AVISOS (recommended):\n");
+    for (const w of result.warnings) {
+      console.warn(`  [${w.category}] ${basename(w.file)}`);
+      console.warn(`    Regra: ${w.rule}`);
+      if (w.detail) {
+        console.warn(`    Detalhe: ${w.detail}`);
+      }
+      console.warn();
+    }
+  }
+}