@codexa/cli 9.0.31 → 9.0.32

package/protocol/process-return.ts

@@ -9,7 +9,7 @@
  * - Patterns descobertos
  */
 
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { SubagentReturn, Knowledge } from "./subagent-protocol";
 import { addReasoning, addGraphRelation, upsertUtility, getNextDecisionId, runInTransaction } from "../db/schema";
 import { extractUtilitiesFromFile, inferScopeFromPath } from "../commands/patterns";
@@ -22,9 +22,9 @@ interface ProcessResult {
   conflictsDetected: number;
   artifactsAdded: number;
   patternsAdded: number;
-  reasoningAdded: number;  // v8.0
-  relationsAdded: number;  // v8.0
-  utilitiesRegistered: number;  // v8.5
+  reasoningAdded: number;
+  relationsAdded: number;
+  utilitiesRegistered: number;
   errors: string[];
 }
 
@@ -32,24 +32,21 @@ interface ProcessResult {
  * Processa o retorno de um subagent e registra automaticamente
  * todos os dados extraidos no banco
  */
-export function processSubagentReturn(
+export async function processSubagentReturn(
   specId: string,
   taskId: number,
   taskNumber: number,
   data: SubagentReturn
-): ProcessResult {
-  // v10.2: Wrap entire processing in atomic transaction
-  // Prevents race conditions in parallel tasks (pattern storage, knowledge dedup)
-  return runInTransaction(() => processSubagentReturnInner(specId, taskId, taskNumber, data));
+): Promise<ProcessResult> {
+  return await runInTransaction(async (tx) => await processSubagentReturnInner(specId, taskId, taskNumber, data));
 }
 
-function processSubagentReturnInner(
+async function processSubagentReturnInner(
   specId: string,
   taskId: number,
   taskNumber: number,
   data: SubagentReturn
-): ProcessResult {
-  const db = getDb();
+): Promise<ProcessResult> {
   const now = new Date().toISOString();
   const result: ProcessResult = {
     success: true,
@@ -68,14 +65,14 @@ function processSubagentReturnInner(
   if (data.knowledge_to_broadcast && data.knowledge_to_broadcast.length > 0) {
     for (const k of data.knowledge_to_broadcast) {
       try {
-        // v8.3: Deduplicacao - verificar se knowledge identico ja existe
-        const existing = db.query(
-          `SELECT id FROM knowledge WHERE spec_id = ? AND category = ? AND content = ? LIMIT 1`
-        ).get(specId, k.category, k.content) as any;
+        const existing = await dbGet<any>(
+          `SELECT id FROM knowledge WHERE spec_id = ? AND category = ? AND content = ? LIMIT 1`,
+          [specId, k.category, k.content]
+        );
 
-        if (existing) continue; // Skip duplicata
+        if (existing) continue;
 
-        db.run(
+        await dbRun(
           `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
            VALUES (?, ?, ?, ?, ?, 'all', ?)`,
           [specId, taskId, k.category, k.content, k.severity, now]
@@ -96,7 +93,7 @@ function processSubagentReturnInner(
       while (retries > 0 && !inserted) {
         try {
           const decisionId = getNextDecisionId(specId);
-          db.run(
+          await dbRun(
             `INSERT INTO decisions (id, spec_id, task_ref, title, decision, rationale, status, created_at)
              VALUES (?, ?, ?, ?, ?, ?, 'active', ?)`,
             [decisionId, specId, taskNumber, dec.title, dec.decision, dec.rationale || null, now]
@@ -119,9 +116,10 @@ function processSubagentReturnInner(
   // 2b. v9.5: Conflict check (WARNING, nao bloqueia subagent)
   if (savedDecisionIds.length > 0) {
     try {
-      const existingDecisions = db
-        .query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'")
-        .all(specId) as any[];
+      const existingDecisions = await dbAll<any>(
+        "SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'",
+        [specId]
+      );
 
       for (const dec of data.decisions_made!) {
         const othersOnly = existingDecisions.filter(
@@ -132,7 +130,7 @@ function processSubagentReturnInner(
         const analysis = detectConflicts(dec.title, dec.decision, othersOnly);
         if (analysis.hasConflict) {
           for (const conflict of analysis.conflictingDecisions) {
-            db.run(
+            await dbRun(
               `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
                VALUES (?, ?, 'decision', ?, 'warning', 'all', ?)`,
               [specId, taskId,
@@ -157,7 +155,7 @@ function processSubagentReturnInner(
 
   for (const file of allFiles) {
     try {
-      db.run(
+      await dbRun(
         `INSERT OR REPLACE INTO artifacts (spec_id, task_ref, path, action, created_at)
          VALUES (?, ?, ?, ?, ?)`,
         [specId, taskNumber, file.path, file.action, now]
@@ -171,11 +169,10 @@ function processSubagentReturnInner(
   // 4. Registrar Patterns descobertos no contexto
   if (data.patterns_discovered && data.patterns_discovered.length > 0) {
     try {
-      const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(specId) as any;
+      const context = await dbGet<any>("SELECT * FROM context WHERE spec_id = ?", [specId]);
       const currentPatterns = context?.patterns ? JSON.parse(context.patterns) : [];
 
       for (const pattern of data.patterns_discovered) {
-        // v10.0: Dedup — skip if pattern text already exists
         if (currentPatterns.some((p: any) => p.pattern === pattern)) {
           continue;
         }
@@ -187,12 +184,11 @@ function processSubagentReturnInner(
         result.patternsAdded++;
       }
 
-      // v10.0: Cap at 50 patterns (keep most recent)
       if (currentPatterns.length > 50) {
         currentPatterns.splice(0, currentPatterns.length - 50);
       }
 
-      db.run(
+      await dbRun(
         "UPDATE context SET patterns = ?, updated_at = ? WHERE spec_id = ?",
         [JSON.stringify(currentPatterns), now, specId]
       );
@@ -206,12 +202,13 @@ function processSubagentReturnInner(
     for (const pattern of data.patterns_discovered) {
       try {
         const content = `Pattern descoberto: ${pattern}`;
-        const existing = db.query(
-          `SELECT id FROM knowledge WHERE spec_id = ? AND category = 'pattern' AND content = ? LIMIT 1`
-        ).get(specId, content) as any;
+        const existing = await dbGet<any>(
+          `SELECT id FROM knowledge WHERE spec_id = ? AND category = 'pattern' AND content = ? LIMIT 1`,
+          [specId, content]
+        );
 
         if (!existing) {
-          db.run(
+          await dbRun(
             `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
              VALUES (?, ?, 'pattern', ?, 'info', 'all', ?)`,
             [specId, taskId, content, now]
@@ -225,7 +222,7 @@ function processSubagentReturnInner(
   if (data.status === "blocked" && data.blockers) {
     for (const blocker of data.blockers) {
       try {
-        db.run(
+        await dbRun(
           `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
            VALUES (?, ?, 'blocker', ?, 'critical', 'all', ?)`,
           [specId, taskId, blocker, now]
@@ -240,9 +237,8 @@ function processSubagentReturnInner(
   // 6. v8.0: Registrar Reasoning no reasoning_log
   if (data.reasoning) {
     try {
-      // Abordagem principal
       if (data.reasoning.approach) {
-        addReasoning(specId, taskId, {
+        await addReasoning(specId, taskId, {
           category: "decision",
           thought: `Abordagem: ${data.reasoning.approach}`,
           relatedFiles: [...data.files_created, ...data.files_modified],
@@ -251,10 +247,9 @@ function processSubagentReturnInner(
         result.reasoningAdded++;
       }
 
-      // Desafios encontrados
       if (data.reasoning.challenges && data.reasoning.challenges.length > 0) {
         for (const challenge of data.reasoning.challenges) {
-          addReasoning(specId, taskId, {
+          await addReasoning(specId, taskId, {
             category: "challenge",
             thought: challenge,
             relatedFiles: [...data.files_created, ...data.files_modified],
@@ -264,10 +259,9 @@ function processSubagentReturnInner(
         }
       }
 
-      // Alternativas consideradas
       if (data.reasoning.alternatives && data.reasoning.alternatives.length > 0) {
         for (const alt of data.reasoning.alternatives) {
-          addReasoning(specId, taskId, {
+          await addReasoning(specId, taskId, {
             category: "decision",
             thought: `Alternativa considerada: ${alt}`,
             relatedFiles: [...data.files_created, ...data.files_modified],
@@ -277,9 +271,8 @@ function processSubagentReturnInner(
         }
       }
 
-      // Recomendações para próximas tasks
       if (data.reasoning.recommendations) {
-        addReasoning(specId, taskId, {
+        await addReasoning(specId, taskId, {
           category: "recommendation",
           thought: data.reasoning.recommendations,
           relatedFiles: [...data.files_created, ...data.files_modified],
@@ -294,9 +287,8 @@ function processSubagentReturnInner(
 
   // 7. v8.0: Criar relações no knowledge graph
   try {
-    // Relação: task -> arquivos criados
     for (const file of data.files_created) {
-      addGraphRelation(specId, {
+      await addGraphRelation(specId, {
         sourceType: "task",
         sourceId: String(taskId),
         targetType: "file",
@@ -306,9 +298,8 @@ function processSubagentReturnInner(
       result.relationsAdded++;
     }
 
-    // Relação: task -> arquivos modificados
     for (const file of data.files_modified) {
-      addGraphRelation(specId, {
+      await addGraphRelation(specId, {
         sourceType: "task",
         sourceId: String(taskId),
         targetType: "file",
@@ -318,11 +309,10 @@ function processSubagentReturnInner(
       result.relationsAdded++;
     }
 
-    // Relação: decision -> arquivos (usa IDs salvos na seção 2, não gera novos)
     if (savedDecisionIds.length > 0) {
       for (const decisionId of savedDecisionIds) {
         for (const file of [...data.files_created, ...data.files_modified]) {
-          addGraphRelation(specId, {
+          await addGraphRelation(specId, {
             sourceType: "decision",
             sourceId: decisionId,
             targetType: "file",
@@ -334,11 +324,10 @@ function processSubagentReturnInner(
       }
     }
 
-    // Relação: pattern -> arquivos (se patterns descobertos)
     if (data.patterns_discovered) {
       for (const pattern of data.patterns_discovered) {
         for (const file of data.files_created) {
-          addGraphRelation(specId, {
+          await addGraphRelation(specId, {
             sourceType: "pattern",
             sourceId: pattern,
             targetType: "file",
@@ -355,10 +344,9 @@ function processSubagentReturnInner(
 
   // 8. v8.5: Registrar utilities de arquivos criados/modificados (DRY map)
   try {
-    // 8a. Usar utilities declaradas pelo subagent (metadata mais rica)
     if (data.utilities_created && data.utilities_created.length > 0) {
       for (const util of data.utilities_created) {
-        upsertUtility({
+        await upsertUtility({
           filePath: util.file,
           utilityName: util.name,
           utilityType: util.type || "function",
@@ -370,12 +358,11 @@ function processSubagentReturnInner(
       }
     }
 
-    // 8b. Fallback: escanear exports de arquivos criados/modificados
     for (const file of allFiles.map(f => f.path)) {
       const utilities = extractUtilitiesFromFile(file);
       const scope = inferScopeFromPath(file);
       for (const util of utilities) {
-        upsertUtility({
+        await upsertUtility({
           filePath: file,
           utilityName: util.name,
           utilityType: util.type,
@@ -386,7 +373,6 @@ function processSubagentReturnInner(
       }
     }
   } catch (e) {
-    // Nao-critico: nao falhar processamento por extracao de utilities
     result.errors.push(`Aviso utilities: ${(e as Error).message}`);
   }
 
@@ -415,14 +401,12 @@ export function formatProcessResult(result: ProcessResult): string {
   if (result.patternsAdded > 0) {
     output += `    + ${result.patternsAdded} pattern(s) adicionado(s) ao contexto\n`;
   }
-  // v8.0: Novas métricas
   if (result.reasoningAdded > 0) {
     output += `    + ${result.reasoningAdded} raciocinio(s) registrado(s) no historico\n`;
   }
   if (result.relationsAdded > 0) {
     output += `    + ${result.relationsAdded} relacao(oes) criada(s) no grafo de conhecimento\n`;
   }
-  // v8.5: Utilities registradas
   if (result.utilitiesRegistered > 0) {
     output += `    + ${result.utilitiesRegistered} utilidade(s) registrada(s) no mapa DRY\n`;
   }
@@ -435,4 +419,4 @@ export function formatProcessResult(result: ProcessResult): string {
   }
 
   return output;
-}
+}

package/simplify/prompt-builder.test.ts

@@ -1,5 +1,6 @@
-import { describe, it, expect, beforeEach } from "bun:test";
-import { getDb } from "../db/connection";
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { createClient } from "@libsql/client";
+import { setClient, resetClient, dbRun } from "../db/connection";
 import { initSchema, runMigrations } from "../db/schema";
 import {
   buildSimplifyPrompt,
@@ -29,7 +30,7 @@ function createTmpFile(name: string, content: string): string {
   return path;
 }
 
-function insertStandard(opts: {
+async function insertStandard(opts: {
   category: string;
   scope: string;
   rule: string;
@@ -38,8 +39,7 @@ function insertStandard(opts: {
   anti_examples?: string;
   semantic_query?: string | null;
 }) {
-  const db = getDb();
-  db.run(
+  await dbRun(
     `INSERT INTO standards (category, scope, rule, examples, anti_examples, enforcement, semantic_query, expect, source, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, 'no_match', 'test', datetime('now'))`,
     [
@@ -59,51 +59,55 @@ function insertStandard(opts: {
 // ═══════════════════════════════════════════════════════════════
 
 describe("simplify prompt-builder", () => {
-  beforeEach(() => {
-    initSchema();
-    runMigrations();
-    const db = getDb();
-    db.run("DELETE FROM standards");
-    // Cleanup tmp
+  beforeEach(async () => {
+    const client = createClient({ url: ":memory:" });
+    setClient(client);
+    await initSchema();
+    await runMigrations();
+    await dbRun("DELETE FROM standards");
     if (existsSync(TMP_DIR)) {
       rmSync(TMP_DIR, { recursive: true, force: true });
     }
   });
 
+  afterEach(() => {
+    resetClient();
+  });
+
   // ── getStandardsForSimplify ─────────────────────────────────
 
   describe("getStandardsForSimplify", () => {
-    it("returns standards filtered by scope", () => {
-      insertStandard({ category: "code", scope: "all", rule: "Global rule" });
-      insertStandard({ category: "code", scope: "backend", rule: "Backend rule" });
-      insertStandard({ category: "code", scope: "frontend", rule: "Frontend rule" });
+    it("returns standards filtered by scope", async () => {
+      await insertStandard({ category: "code", scope: "all", rule: "Global rule" });
+      await insertStandard({ category: "code", scope: "backend", rule: "Backend rule" });
+      await insertStandard({ category: "code", scope: "frontend", rule: "Frontend rule" });
 
-      const backendStds = getStandardsForSimplify("backend");
+      const backendStds = await getStandardsForSimplify("backend");
       expect(backendStds.length).toBe(2);
       expect(backendStds.map(s => s.rule)).toContain("Global rule");
       expect(backendStds.map(s => s.rule)).toContain("Backend rule");
       expect(backendStds.map(s => s.rule)).not.toContain("Frontend rule");
     });
 
-    it("returns all standards when scope is 'all'", () => {
-      insertStandard({ category: "code", scope: "all", rule: "Global rule" });
-      insertStandard({ category: "code", scope: "backend", rule: "Backend rule" });
+    it("returns all standards when scope is 'all'", async () => {
+      await insertStandard({ category: "code", scope: "all", rule: "Global rule" });
+      await insertStandard({ category: "code", scope: "backend", rule: "Backend rule" });
 
-      const allStds = getStandardsForSimplify("all");
+      const allStds = await getStandardsForSimplify("all");
       expect(allStds.length).toBe(1);
       expect(allStds[0].rule).toBe("Global rule");
     });
 
-    it("returns empty array when no standards exist", () => {
-      const stds = getStandardsForSimplify("backend");
+    it("returns empty array when no standards exist", async () => {
+      const stds = await getStandardsForSimplify("backend");
       expect(stds.length).toBe(0);
     });
 
-    it("orders required before recommended", () => {
-      insertStandard({ category: "code", scope: "all", rule: "Recommended", enforcement: "recommended" });
-      insertStandard({ category: "code", scope: "all", rule: "Required", enforcement: "required" });
+    it("orders required before recommended", async () => {
+      await insertStandard({ category: "code", scope: "all", rule: "Recommended", enforcement: "recommended" });
+      await insertStandard({ category: "code", scope: "all", rule: "Required", enforcement: "required" });
 
-      const stds = getStandardsForSimplify("all");
+      const stds = await getStandardsForSimplify("all");
       expect(stds[0].rule).toBe("Required");
       expect(stds[1].rule).toBe("Recommended");
     });
@@ -179,8 +183,8 @@ describe("simplify prompt-builder", () => {
   // ── buildSimplifyPrompt ─────────────────────────────────────
 
   describe("buildSimplifyPrompt", () => {
-    it("builds refactor prompt with standards and files", () => {
-      insertStandard({
+    it("builds refactor prompt with standards and files", async () => {
+      await insertStandard({
         category: "code",
         scope: "all",
         rule: "Use function declarations",
@@ -191,7 +195,7 @@ describe("simplify prompt-builder", () => {
       const filePath = createTmpFile("test.ts", "export function hello() {}");
       const files: SimplifyFile[] = [{ path: filePath, action: "created" }];
 
-      const prompt = buildSimplifyPrompt(files, "all", "refactor");
+      const prompt = await buildSimplifyPrompt(files, "all", "refactor");
 
       expect(prompt).toContain("## Standards do Projeto");
       expect(prompt).toContain("Use function declarations");
@@ -201,53 +205,51 @@ describe("simplify prompt-builder", () => {
       expect(prompt).toContain("Preservem funcionalidade");
     });
 
-    it("builds audit prompt with analysis-only instructions", () => {
-      insertStandard({ category: "code", scope: "all", rule: "Some rule" });
+    it("builds audit prompt with analysis-only instructions", async () => {
+      await insertStandard({ category: "code", scope: "all", rule: "Some rule" });
 
       const filePath = createTmpFile("test2.ts", "export const x = 1;");
       const files: SimplifyFile[] = [{ path: filePath, action: "modified" }];
 
-      const prompt = buildSimplifyPrompt(files, "all", "audit");
+      const prompt = await buildSimplifyPrompt(files, "all", "audit");
 
       expect(prompt).toContain("NAO aplique mudancas");
       expect(prompt).toContain("reporte oportunidades");
       expect(prompt).toContain("(modificado)");
     });
 
-    it("handles no standards gracefully", () => {
+    it("handles no standards gracefully", async () => {
       const filePath = createTmpFile("test3.ts", "export const y = 2;");
       const files: SimplifyFile[] = [{ path: filePath, action: "created" }];
 
-      const prompt = buildSimplifyPrompt(files, "all", "refactor");
+      const prompt = await buildSimplifyPrompt(files, "all", "refactor");
 
-      // Should still have files and instructions sections
       expect(prompt).toContain("## Arquivos para Simplificar");
       expect(prompt).toContain("## Instrucoes");
-      // Should NOT have standards section
       expect(prompt).not.toContain("## Standards do Projeto");
     });
 
-    it("filters out non-existing files", () => {
+    it("filters out non-existing files", async () => {
       const filePath = createTmpFile("exists.ts", "export const z = 3;");
       const files: SimplifyFile[] = [
         { path: filePath, action: "created" },
         { path: "/nonexistent/file.ts", action: "modified" },
       ];
 
-      const prompt = buildSimplifyPrompt(files, "all", "refactor");
+      const prompt = await buildSimplifyPrompt(files, "all", "refactor");
 
       expect(prompt).toContain("exists.ts");
       expect(prompt).not.toContain("nonexistent");
     });
 
-    it("filters standards by scope", () => {
-      insertStandard({ category: "code", scope: "backend", rule: "Backend only rule" });
-      insertStandard({ category: "code", scope: "frontend", rule: "Frontend only rule" });
+    it("filters standards by scope", async () => {
+      await insertStandard({ category: "code", scope: "backend", rule: "Backend only rule" });
+      await insertStandard({ category: "code", scope: "frontend", rule: "Frontend only rule" });
 
       const filePath = createTmpFile("test4.ts", "export const a = 1;");
       const files: SimplifyFile[] = [{ path: filePath, action: "created" }];
 
-      const prompt = buildSimplifyPrompt(files, "backend", "refactor");
+      const prompt = await buildSimplifyPrompt(files, "backend", "refactor");
 
       expect(prompt).toContain("Backend only rule");
       expect(prompt).not.toContain("Frontend only rule");

package/simplify/prompt-builder.ts

@@ -4,7 +4,7 @@
 // from SQLite. Generates context files for the simplifier agent.
 // ═══════════════════════════════════════════════════════════════
 
-import { getDb } from "../db/connection";
+import { dbAll } from "../db/connection";
 import { existsSync, mkdirSync } from "fs";
 import { resolve, join } from "path";
 
@@ -42,16 +42,14 @@ export type SimplifyMode = "refactor" | "audit";
 // STANDARDS RETRIEVAL
 // ═══════════════════════════════════════════════════════════════
 
-export function getStandardsForSimplify(agentDomain: string): StandardRow[] {
-  const db = getDb();
-  return db
-    .query(
-      `SELECT id, category, scope, rule, examples, anti_examples, enforcement, semantic_query
-       FROM standards
-       WHERE (scope = 'all' OR scope = ?)
-       ORDER BY enforcement DESC, category`
-    )
-    .all(agentDomain) as StandardRow[];
+export async function getStandardsForSimplify(agentDomain: string): Promise<StandardRow[]> {
+  return dbAll<StandardRow>(
+    `SELECT id, category, scope, rule, examples, anti_examples, enforcement, semantic_query
+     FROM standards
+     WHERE (scope = 'all' OR scope = ?)
+     ORDER BY enforcement DESC, category`,
+    [agentDomain]
+  );
 }
 
 // ═══════════════════════════════════════════════════════════════
@@ -124,12 +122,12 @@ function parseJsonArray(json: string | null): string[] {
 // PROMPT BUILDER
 // ═══════════════════════════════════════════════════════════════
 
-export function buildSimplifyPrompt(
+export async function buildSimplifyPrompt(
   files: SimplifyFile[],
   agentDomain: string,
   mode: SimplifyMode
-): string {
-  const standards = getStandardsForSimplify(agentDomain);
+): Promise<string> {
+  const standards = await getStandardsForSimplify(agentDomain);
   const existingFiles = files.filter(f => existsSync(f.path));
 
   let prompt = "";