@codexa/cli 9.0.30 → 9.0.32

package/db/test-helpers.ts

@@ -1,33 +1,22 @@
-import { getDb } from "./connection";
+import { dbRun } from "./connection";
 
-/**
- * Limpa todas as tabelas do DB respeitando ordem de FK constraints.
- * Usa PRAGMA foreign_keys = OFF como safety net.
- *
- * Uso: beforeEach(() => { initSchema(); cleanDb(); });
- */
-export function cleanDb() {
-  const db = getDb();
-  db.run("PRAGMA foreign_keys = OFF");
+export async function cleanDb() {
   try {
-    // Folhas (sem dependentes) primeiro
-    db.run("DELETE FROM knowledge_acknowledgments");
-    db.run("DELETE FROM agent_performance");
-    db.run("DELETE FROM reasoning_log");
-    db.run("DELETE FROM knowledge_graph");
-    db.run("DELETE FROM gate_bypasses");
-    db.run("DELETE FROM snapshots");
-    db.run("DELETE FROM review");
-    db.run("DELETE FROM project_utilities");
-    db.run("DELETE FROM artifacts");
-    db.run("DELETE FROM decisions");
-    // Dependentes de knowledge (antes de knowledge)
-    db.run("DELETE FROM knowledge");
-    // Dependentes de tasks/specs
-    db.run("DELETE FROM tasks");
-    db.run("DELETE FROM context");
-    db.run("DELETE FROM specs");
-  } finally {
-    db.run("PRAGMA foreign_keys = ON");
+    await dbRun("DELETE FROM knowledge_acknowledgments");
+    await dbRun("DELETE FROM agent_performance");
+    await dbRun("DELETE FROM reasoning_log");
+    await dbRun("DELETE FROM knowledge_graph");
+    await dbRun("DELETE FROM gate_bypasses");
+    await dbRun("DELETE FROM snapshots");
+    await dbRun("DELETE FROM review");
+    await dbRun("DELETE FROM project_utilities");
+    await dbRun("DELETE FROM artifacts");
+    await dbRun("DELETE FROM decisions");
+    await dbRun("DELETE FROM knowledge");
+    await dbRun("DELETE FROM tasks");
+    await dbRun("DELETE FROM context");
+    await dbRun("DELETE FROM specs");
+  } catch {
+    // Tables may not exist yet
   }
 }

package/gates/standards-validator.test.ts

@@ -1,13 +1,13 @@
-import { describe, it, expect, beforeEach, mock, spyOn } from "bun:test";
-import { getDb } from "../db/connection";
+import { describe, it, expect, beforeEach, afterEach, spyOn } from "bun:test";
+import { createClient } from "@libsql/client";
+import { setClient, resetClient, dbRun } from "../db/connection";
 import { initSchema, runMigrations } from "../db/schema";
 import { writeFileSync, mkdirSync, rmSync, existsSync } from "fs";
 import { join } from "path";
 
-// Mock grepai functions before importing validator
 import * as patterns from "../commands/patterns";
 
-import { validateAgainstStandards, printValidationResult } from "./standards-validator";
+import { validateAgainstStandards } from "./standards-validator";
 
 // ═══════════════════════════════════════════════════════════════
 // HELPERS
@@ -28,7 +28,7 @@ function createTmpFile(name: string, content: string): string {
   return path;
 }
 
-function insertStandard(opts: {
+async function insertStandard(opts: {
   category: string;
   scope: string;
   rule: string;
@@ -37,8 +37,7 @@ function insertStandard(opts: {
   semantic_query?: string | null;
   expect?: string;
 }) {
-  const db = getDb();
-  db.run(
+  await dbRun(
     `INSERT INTO standards (category, scope, rule, anti_examples, enforcement, semantic_query, expect, source, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, 'test', datetime('now'))`,
     [
@@ -58,33 +57,37 @@ function insertStandard(opts: {
 // ═══════════════════════════════════════════════════════════════
 
 describe("standards-validator", () => {
-  beforeEach(() => {
-    initSchema();
-    runMigrations();
-    const db = getDb();
-    db.run("DELETE FROM standards");
+  beforeEach(async () => {
+    const client = createClient({ url: ":memory:" });
+    setClient(client);
+    await initSchema();
+    await runMigrations();
+    await dbRun("DELETE FROM standards");
 
-    // Clean tmp files
     if (existsSync(TMP_DIR)) {
       rmSync(TMP_DIR, { recursive: true });
     }
   });
 
+  afterEach(() => {
+    resetClient();
+  });
+
   // ─────────────────────────────────────────────────────────
   // BASE CASES
   // ─────────────────────────────────────────────────────────
 
-  it("returns passed when no standards exist", () => {
+  it("returns passed when no standards exist", async () => {
     const file = createTmpFile("test.ts", "export const x = 1;");
-    const result = validateAgainstStandards([file], "all");
+    const result = await validateAgainstStandards([file], "all");
     expect(result.passed).toBe(true);
     expect(result.violations).toHaveLength(0);
     expect(result.warnings).toHaveLength(0);
   });
 
-  it("returns passed when files list is empty", () => {
-    insertStandard({ category: "code", scope: "all", rule: "No console.log" });
-    const result = validateAgainstStandards([], "all");
+  it("returns passed when files list is empty", async () => {
+    await insertStandard({ category: "code", scope: "all", rule: "No console.log" });
+    const result = await validateAgainstStandards([], "all");
     expect(result.passed).toBe(true);
   });
 
@@ -92,37 +95,37 @@ describe("standards-validator", () => {
   // TEXTUAL VALIDATION (anti_examples)
   // ─────────────────────────────────────────────────────────
 
-  it("detects anti_examples violation in file content", () => {
+  it("detects anti_examples violation in file content", async () => {
     const file = createTmpFile("api.ts", 'console.log("debug"); export function handle() {}');
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "Nao usar console.log",
       anti_examples: JSON.stringify(["console.log"]),
     });
 
-    const result = validateAgainstStandards([file], "all");
+    const result = await validateAgainstStandards([file], "all");
     expect(result.passed).toBe(false);
     expect(result.violations).toHaveLength(1);
     expect(result.violations[0].detail).toContain("console.log");
   });
 
-  it("passes when anti_examples not found in file", () => {
+  it("passes when anti_examples not found in file", async () => {
     const file = createTmpFile("api.ts", "export function handle() { return 'ok'; }");
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "Nao usar console.log",
       anti_examples: JSON.stringify(["console.log"]),
     });
 
-    const result = validateAgainstStandards([file], "all");
+    const result = await validateAgainstStandards([file], "all");
     expect(result.passed).toBe(true);
   });
 
-  it("treats recommended enforcement as warning not violation", () => {
+  it("treats recommended enforcement as warning not violation", async () => {
     const file = createTmpFile("api.ts", 'console.log("test");');
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "Evitar console.log",
@@ -130,70 +133,67 @@ describe("standards-validator", () => {
       enforcement: "recommended",
     });
 
-    const result = validateAgainstStandards([file], "all");
-    expect(result.passed).toBe(true); // recommended does NOT block
+    const result = await validateAgainstStandards([file], "all");
+    expect(result.passed).toBe(true);
     expect(result.warnings).toHaveLength(1);
     expect(result.violations).toHaveLength(0);
   });
 
-  it("filters standards by scope", () => {
+  it("filters standards by scope", async () => {
     const file = createTmpFile("api.ts", 'console.log("test");');
 
-    // Standard for frontend scope only
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "frontend",
       rule: "Frontend: no console.log",
       anti_examples: JSON.stringify(["console.log"]),
     });
 
-    // Validate with backend domain — should NOT match frontend standard
-    const result = validateAgainstStandards([file], "backend");
+    const result = await validateAgainstStandards([file], "backend");
     expect(result.passed).toBe(true);
   });
 
-  it("matches scope 'all' for any domain", () => {
+  it("matches scope 'all' for any domain", async () => {
     const file = createTmpFile("api.ts", 'console.log("test");');
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "No console.log",
       anti_examples: JSON.stringify(["console.log"]),
     });
 
-    const result = validateAgainstStandards([file], "backend");
+    const result = await validateAgainstStandards([file], "backend");
     expect(result.passed).toBe(false);
   });
 
-  it("skips nonexistent files gracefully", () => {
-    insertStandard({
+  it("skips nonexistent files gracefully", async () => {
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "No eval",
       anti_examples: JSON.stringify(["eval("]),
     });
 
-    const result = validateAgainstStandards(["/nonexistent/file.ts"], "all");
+    const result = await validateAgainstStandards(["/nonexistent/file.ts"], "all");
     expect(result.passed).toBe(true);
   });
 
-  it("handles invalid anti_examples JSON gracefully", () => {
+  it("handles invalid anti_examples JSON gracefully", async () => {
     const file = createTmpFile("api.ts", "export const x = 1;");
-    const db = getDb();
-    db.run(
+    await dbRun(
       `INSERT INTO standards (category, scope, rule, anti_examples, enforcement, source, created_at)
        VALUES ('code', 'all', 'Bad JSON', 'not-valid-json', 'required', 'test', datetime('now'))`
     );
 
-    const result = validateAgainstStandards([file], "all");
-    expect(result.passed).toBe(true); // Invalid JSON should not crash
+    const result = await validateAgainstStandards([file], "all");
+    expect(result.passed).toBe(true);
   });
 
   // ─────────────────────────────────────────────────────────
   // SEMANTIC VALIDATION (grepai)
   // ─────────────────────────────────────────────────────────
 
-  it("detects no_match violation when grepai finds matching file", () => {
+  it("detects no_match violation when grepai finds matching file", async () => {
     const file = createTmpFile("handler.ts", "export function handle() {}");
     const resolvedPath = join(TMP_DIR, "handler.ts").replace(/\\/g, "/");
 
@@ -202,7 +202,7 @@ describe("standards-validator", () => {
       { path: resolvedPath, score: 0.85 },
     ]);
 
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "No .then() chains",
@@ -210,7 +210,7 @@ describe("standards-validator", () => {
       expect: "no_match",
     });
 
-    const result = validateAgainstStandards([file], "all");
+    const result = await validateAgainstStandards([file], "all");
     expect(result.passed).toBe(false);
     expect(result.violations).toHaveLength(1);
     expect(result.violations[0].detail).toContain("Violacao semantica");
@@ -220,13 +220,13 @@ describe("standards-validator", () => {
     searchSpy.mockRestore();
   });
 
-  it("passes no_match when grepai finds no matches", () => {
+  it("passes no_match when grepai finds no matches", async () => {
     const file = createTmpFile("clean.ts", "export const x = 1;");
 
     const availSpy = spyOn(patterns, "isGrepaiAvailable").mockReturnValue(true);
     const searchSpy = spyOn(patterns, "searchWithGrepai").mockReturnValue([]);
 
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "No .then() chains",
@@ -234,20 +234,20 @@ describe("standards-validator", () => {
       expect: "no_match",
     });
 
-    const result = validateAgainstStandards([file], "all");
+    const result = await validateAgainstStandards([file], "all");
     expect(result.passed).toBe(true);
 
     availSpy.mockRestore();
     searchSpy.mockRestore();
   });
 
-  it("detects must_match violation when grepai finds no match", () => {
+  it("detects must_match violation when grepai finds no match", async () => {
     const file = createTmpFile("service.ts", "export function process() {}");
 
     const availSpy = spyOn(patterns, "isGrepaiAvailable").mockReturnValue(true);
     const searchSpy = spyOn(patterns, "searchWithGrepai").mockReturnValue([]);
 
-    insertStandard({
+    await insertStandard({
       category: "practice",
       scope: "all",
       rule: "Must have error handling",
@@ -255,7 +255,7 @@ describe("standards-validator", () => {
       expect: "must_match",
     });
 
-    const result = validateAgainstStandards([file], "all");
+    const result = await validateAgainstStandards([file], "all");
     expect(result.passed).toBe(false);
     expect(result.violations).toHaveLength(1);
     expect(result.violations[0].detail).toContain("Padrao obrigatorio nao encontrado");
@@ -264,7 +264,7 @@ describe("standards-validator", () => {
     searchSpy.mockRestore();
   });
 
-  it("passes must_match when grepai finds matching file", () => {
+  it("passes must_match when grepai finds matching file", async () => {
     const file = createTmpFile("service.ts", "try { } catch (e) { }");
     const resolvedPath = join(TMP_DIR, "service.ts").replace(/\\/g, "/");
 
@@ -273,7 +273,7 @@ describe("standards-validator", () => {
       { path: resolvedPath, score: 0.9 },
     ]);
 
-    insertStandard({
+    await insertStandard({
       category: "practice",
       scope: "all",
       rule: "Must have error handling",
@@ -281,23 +281,23 @@ describe("standards-validator", () => {
       expect: "must_match",
     });
 
-    const result = validateAgainstStandards([file], "all");
+    const result = await validateAgainstStandards([file], "all");
     expect(result.passed).toBe(true);
 
     availSpy.mockRestore();
     searchSpy.mockRestore();
   });
 
-  it("ignores grepai results below score threshold", () => {
+  it("ignores grepai results below score threshold", async () => {
     const file = createTmpFile("maybe.ts", "export const x = 1;");
     const resolvedPath = join(TMP_DIR, "maybe.ts").replace(/\\/g, "/");
 
     const availSpy = spyOn(patterns, "isGrepaiAvailable").mockReturnValue(true);
     const searchSpy = spyOn(patterns, "searchWithGrepai").mockReturnValue([
-      { path: resolvedPath, score: 0.5 }, // Below 0.7 threshold
+      { path: resolvedPath, score: 0.5 },
     ]);
 
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "No console.log",
@@ -305,22 +305,22 @@ describe("standards-validator", () => {
       expect: "no_match",
     });
 
-    const result = validateAgainstStandards([file], "all");
-    expect(result.passed).toBe(true); // Score too low = no match
+    const result = await validateAgainstStandards([file], "all");
+    expect(result.passed).toBe(true);
 
     availSpy.mockRestore();
     searchSpy.mockRestore();
   });
 
-  it("ignores grepai results for files not in validation list", () => {
+  it("ignores grepai results for files not in validation list", async () => {
     const file = createTmpFile("target.ts", "export const x = 1;");
 
     const availSpy = spyOn(patterns, "isGrepaiAvailable").mockReturnValue(true);
     const searchSpy = spyOn(patterns, "searchWithGrepai").mockReturnValue([
-      { path: "/some/other/file.ts", score: 0.95 }, // High score but wrong file
+      { path: "/some/other/file.ts", score: 0.95 },
     ]);
 
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "No eval",
@@ -328,8 +328,8 @@ describe("standards-validator", () => {
       expect: "no_match",
     });
 
-    const result = validateAgainstStandards([file], "all");
-    expect(result.passed).toBe(true); // Match is for a different file
+    const result = await validateAgainstStandards([file], "all");
+    expect(result.passed).toBe(true);
 
     availSpy.mockRestore();
     searchSpy.mockRestore();
@@ -339,12 +339,12 @@ describe("standards-validator", () => {
   // FALLBACK (grepai unavailable)
   // ─────────────────────────────────────────────────────────
 
-  it("falls back to anti_examples when grepai not available", () => {
+  it("falls back to anti_examples when grepai not available", async () => {
     const file = createTmpFile("api.ts", 'eval("alert(1)");');
 
     const availSpy = spyOn(patterns, "isGrepaiAvailable").mockReturnValue(false);
 
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "No eval",
@@ -353,19 +353,19 @@ describe("standards-validator", () => {
       expect: "no_match",
     });
 
-    const result = validateAgainstStandards([file], "all");
-    expect(result.passed).toBe(false); // Falls back to anti_examples check
+    const result = await validateAgainstStandards([file], "all");
+    expect(result.passed).toBe(false);
     expect(result.violations).toHaveLength(1);
 
     availSpy.mockRestore();
   });
 
-  it("skips must_match standards when grepai not available", () => {
+  it("skips must_match standards when grepai not available", async () => {
     const file = createTmpFile("service.ts", "export function process() {}");
 
     const availSpy = spyOn(patterns, "isGrepaiAvailable").mockReturnValue(false);
 
-    insertStandard({
+    await insertStandard({
       category: "practice",
       scope: "all",
       rule: "Must have error handling",
@@ -373,8 +373,8 @@ describe("standards-validator", () => {
       expect: "must_match",
     });
 
-    const result = validateAgainstStandards([file], "all");
-    expect(result.passed).toBe(true); // Cannot validate must_match without grepai
+    const result = await validateAgainstStandards([file], "all");
+    expect(result.passed).toBe(true);
 
     availSpy.mockRestore();
   });
@@ -383,7 +383,7 @@ describe("standards-validator", () => {
   // CAP & MIXED
   // ─────────────────────────────────────────────────────────
 
-  it("caps semantic standards at MAX_SEMANTIC_QUERIES (10)", () => {
+  it("caps semantic standards at MAX_SEMANTIC_QUERIES (10)", async () => {
     const file = createTmpFile("test.ts", "export const x = 1;");
 
     let callCount = 0;
@@ -393,9 +393,8 @@ describe("standards-validator", () => {
       return [];
     });
 
-    // Insert 15 semantic standards
     for (let i = 0; i < 15; i++) {
-      insertStandard({
+      await insertStandard({
         category: "code",
         scope: "all",
         rule: `Rule ${i}`,
@@ -404,14 +403,14 @@ describe("standards-validator", () => {
       });
     }
 
-    validateAgainstStandards([file], "all");
-    expect(callCount).toBe(10); // Capped at 10
+    await validateAgainstStandards([file], "all");
+    expect(callCount).toBe(10);
 
     availSpy.mockRestore();
     searchSpy.mockRestore();
   });
 
-  it("validates both semantic and textual standards in same run", () => {
+  it("validates both semantic and textual standards in same run", async () => {
     const file = createTmpFile("mixed.ts", 'eval("code"); export const x = 1;');
     const resolvedPath = join(TMP_DIR, "mixed.ts").replace(/\\/g, "/");
 
@@ -420,8 +419,7 @@ describe("standards-validator", () => {
       { path: resolvedPath, score: 0.9 },
     ]);
 
-    // Semantic standard
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "No .then() chains",
@@ -429,17 +427,16 @@ describe("standards-validator", () => {
       expect: "no_match",
     });
 
-    // Textual standard (no semantic_query)
-    insertStandard({
+    await insertStandard({
       category: "code",
       scope: "all",
       rule: "No eval",
       anti_examples: JSON.stringify(["eval("]),
     });
 
-    const result = validateAgainstStandards([file], "all");
+    const result = await validateAgainstStandards([file], "all");
     expect(result.passed).toBe(false);
-    expect(result.violations).toHaveLength(2); // One semantic + one textual
+    expect(result.violations).toHaveLength(2);
 
     availSpy.mockRestore();
     searchSpy.mockRestore();

package/gates/standards-validator.ts

@@ -1,12 +1,8 @@
-import { getDb } from "../db/connection";
+import { dbAll } from "../db/connection";
 import { existsSync, readFileSync } from "fs";
 import { basename, resolve } from "path";
 import { isGrepaiAvailable, searchWithGrepai, getGrepaiWorkspace, type GrepaiResult } from "../commands/patterns";
 
-// ═══════════════════════════════════════════════════════════════
-// INTERFACES
-// ═══════════════════════════════════════════════════════════════
-
 export interface Violation {
   file: string;
   rule: string;
@@ -34,38 +30,27 @@ interface StandardRow {
   expect: string;
 }
 
-// ═══════════════════════════════════════════════════════════════
-// CONSTANTES
-// ═══════════════════════════════════════════════════════════════
-
 const SEMANTIC_SCORE_THRESHOLD = 0.7;
 const MAX_SEMANTIC_QUERIES = 10;
 
-// ═══════════════════════════════════════════════════════════════
-// VALIDACAO PRINCIPAL
-// ═══════════════════════════════════════════════════════════════
-
-export function validateAgainstStandards(
+export async function validateAgainstStandards(
   files: string[],
   agentDomain: string
-): ValidationResult {
-  const db = getDb();
+): Promise<ValidationResult> {
   const violations: Violation[] = [];
   const warnings: Violation[] = [];
 
-  const standards = db
-    .query(
-      `SELECT * FROM standards
-       WHERE (scope = 'all' OR scope = ?)
-       ORDER BY enforcement DESC, category`
-    )
-    .all(agentDomain) as StandardRow[];
+  const standards = await dbAll<StandardRow>(
+    `SELECT * FROM standards
+     WHERE (scope = 'all' OR scope = ?)
+     ORDER BY enforcement DESC, category`,
+    [agentDomain]
+  );
 
   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);
@@ -73,17 +58,14 @@ export function validateAgainstStandards(
     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) {
@@ -96,7 +78,6 @@ export function validateAgainstStandards(
     }
   }
 
-  // === MODO 2: Validacao textual (anti_examples) ===
   if (textualStandards.length > 0) {
     validateTextual(textualStandards, files, violations, warnings);
   }
@@ -108,10 +89,6 @@ export function validateAgainstStandards(
   };
 }
 
-// ═══════════════════════════════════════════════════════════════
-// VALIDACAO SEMANTICA (grepai)
-// ═══════════════════════════════════════════════════════════════
-
 function validateSemantic(
   standards: StandardRow[],
   normalizedFiles: Set<string>,
@@ -125,7 +102,6 @@ function validateSemantic(
 
     const results = searchWithGrepai(std.semantic_query, 20, workspace);
 
-    // 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;
@@ -150,10 +126,6 @@ function validateSemantic(
   }
 }
 
-// ═══════════════════════════════════════════════════════════════
-// VALIDACAO TEXTUAL (anti_examples fallback)
-// ═══════════════════════════════════════════════════════════════
-
 function validateTextual(
   standards: StandardRow[],
   files: string[],
@@ -192,10 +164,6 @@ function validateTextual(
   }
 }
 
-// ═══════════════════════════════════════════════════════════════
-// HELPERS
-// ═══════════════════════════════════════════════════════════════
-
 function addViolation(
   std: StandardRow,
   file: string,