@codexa/cli 9.0.31 → 9.0.32

package/commands/patterns.ts

@@ -7,7 +7,7 @@
 
 import { spawnSync } from "child_process";
 import { readFileSync, existsSync } from "fs";
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 
 // ═══════════════════════════════════════════════════════════════
@@ -43,13 +43,13 @@ export function isValidWorkspaceName(name: string): boolean {
   return WORKSPACE_NAME_REGEX.test(name);
 }
 
-export function getGrepaiWorkspace(): string | null {
+export async function getGrepaiWorkspace(): Promise<string | null> {
   try {
-    initSchema();
-    const db = getDb();
-    const project = db.query(
-      "SELECT grepai_workspace FROM project WHERE id = 'default'"
-    ).get() as any;
+    await initSchema();
+    const project = await dbGet<any>(
+      "SELECT grepai_workspace FROM project WHERE id = 'default'",
+      []
+    );
     return project?.grepai_workspace || null;
   } catch {
     return null;
@@ -126,13 +126,11 @@ function analyzeFile(filePath: string): FileAnalysis | null {
     for (const line of lines) {
       const trimmed = line.trim();
 
-      // Extrair imports (modulo)
       const importMatch = trimmed.match(/^import\s+.*\s+from\s+['"]([^'"]+)['"]/);
       if (importMatch) {
         imports.push(importMatch[1]);
       }
 
-      // Extrair hooks dos imports: import { useX, useY } from "..."
       const hooksInImport = trimmed.match(/^import\s+\{([^}]+)\}\s+from/);
       if (hooksInImport) {
         const specifiers = hooksInImport[1].split(",").map(s => s.trim());
@@ -143,7 +141,6 @@ function analyzeFile(filePath: string): FileAnalysis | null {
         }
       }
 
-      // Extrair exports
       if (trimmed.startsWith("export default")) {
         hasDefaultExport = true;
         exports.push("default");
@@ -158,7 +155,6 @@ function analyzeFile(filePath: string): FileAnalysis | null {
         }
       }
 
-      // Directives
       if (trimmed === "'use client'" || trimmed === '"use client"') {
         directives.push("use client");
         conventions.push("use client");
@@ -172,12 +168,10 @@ function analyzeFile(filePath: string): FileAnalysis | null {
         conventions.push("use cache");
       }
 
-      // Async patterns
       if (trimmed.includes("async function") || trimmed.includes("async (")) {
         if (!conventions.includes("async")) conventions.push("async");
       }
 
-      // React patterns (metadata complementar ao grepai)
       if (trimmed.includes("forwardRef") && !reactPatterns.includes("forwardRef")) {
         reactPatterns.push("forwardRef");
       }
@@ -236,7 +230,6 @@ export function extractUtilitiesFromFile(filePath: string): ExtractedUtility[] {
     for (const line of lines) {
       const trimmed = line.trim();
 
-      // export [async] function name(args): ReturnType
       const funcMatch = trimmed.match(
         /^export\s+(?:async\s+)?function\s+(\w+)\s*(\([^)]*\)(?:\s*:\s*[^{]+)?)?/
       );
@@ -249,7 +242,6 @@ export function extractUtilitiesFromFile(filePath: string): ExtractedUtility[] {
         continue;
       }
 
-      // export const name: Type = ...
       const constMatch = trimmed.match(
         /^export\s+const\s+(\w+)(?:\s*:\s*([^=]+))?\s*=/
       );
@@ -262,21 +254,18 @@ export function extractUtilitiesFromFile(filePath: string): ExtractedUtility[] {
         continue;
       }
 
-      // export class Name
       const classMatch = trimmed.match(/^export\s+class\s+(\w+)/);
       if (classMatch) {
         utilities.push({ name: classMatch[1], type: "class" });
         continue;
       }
 
-      // export interface Name
       const ifaceMatch = trimmed.match(/^export\s+interface\s+(\w+)/);
       if (ifaceMatch) {
         utilities.push({ name: ifaceMatch[1], type: "interface" });
         continue;
       }
 
-      // export type Name
       const typeMatch = trimmed.match(/^export\s+type\s+(\w+)/);
       if (typeMatch) {
         utilities.push({ name: typeMatch[1], type: "type" });
@@ -308,12 +297,11 @@ export function inferScopeFromPath(filePath: string): string {
 // ATUALIZACAO INCREMENTAL DE PATTERNS (chamado por taskDone)
 // ═══════════════════════════════════════════════════════════════
 
-export function updatePatternsIncremental(files: string[], taskNumber: number): void {
-  initSchema();
-  const db = getDb();
+export async function updatePatternsIncremental(files: string[], taskNumber: number): Promise<void> {
+  await initSchema();
   const now = new Date().toISOString();
 
-  const allPatterns = db.query("SELECT * FROM implementation_patterns").all() as any[];
+  const allPatterns = await dbAll<any>("SELECT * FROM implementation_patterns", []);
   if (allPatterns.length === 0) return;
 
   for (const file of files) {
@@ -353,7 +341,7 @@ export function updatePatternsIncremental(files: string[], taskNumber: number):
       const newExtractedFrom = (pattern.extracted_from || 0) + 1;
       const newConfidence = Math.min(newExtractedFrom / 10, 1);
 
-      db.run(
+      await dbRun(
         `UPDATE implementation_patterns
          SET examples = ?, extracted_from = ?, confidence = ?,
              structure = ?, updated_at = ?
@@ -399,11 +387,10 @@ export interface SemanticPattern {
 export function detectSemanticPatterns(workspace?: string): SemanticPattern[] {
   if (!isGrepaiAvailable()) return [];
 
-  const ws = workspace || getGrepaiWorkspace() || undefined;
   const detected: SemanticPattern[] = [];
 
   for (const { query, category, scope } of SEMANTIC_PATTERN_QUERIES) {
-    const results = searchWithGrepai(query, 5, ws);
+    const results = searchWithGrepai(query, 5, workspace);
     if (results.length < 2) continue;
 
     const avgScore = results.reduce((sum, r) => sum + r.score, 0) / results.length;
@@ -422,27 +409,27 @@ export function detectSemanticPatterns(workspace?: string): SemanticPattern[] {
   return detected;
 }
 
-export function saveSemanticPatterns(patterns: SemanticPattern[]): number {
-  initSchema();
-  const db = getDb();
+export async function saveSemanticPatterns(patterns: SemanticPattern[]): Promise<number> {
+  await initSchema();
   const now = new Date().toISOString();
   let saved = 0;
 
   for (const p of patterns) {
     try {
-      const existing = db.query(
-        "SELECT id FROM implementation_patterns WHERE name = ?"
-      ).get(p.name) as any;
+      const existing = await dbGet<any>(
+        "SELECT id FROM implementation_patterns WHERE name = ?",
+        [p.name]
+      );
 
       if (existing) {
-        db.run(
+        await dbRun(
           `UPDATE implementation_patterns SET
             confidence = ?, examples = ?, extracted_from = ?, updated_at = ?
            WHERE id = ?`,
           [p.confidence, JSON.stringify(p.files.map(f => ({ path: f, relevance: p.confidence }))), p.files.length, now, existing.id]
         );
       } else {
-        db.run(
+        await dbRun(
           `INSERT INTO implementation_patterns
             (category, name, scope, applies_to, structure, template, examples, confidence, extracted_from, created_at, updated_at)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -473,19 +460,19 @@ export interface PatternComplianceResult {
   checked: number;
 }
 
-export function validatePatternCompliance(
+export async function validatePatternCompliance(
   files: string[],
   minConfidence: number = 0.7
-): PatternComplianceResult {
-  initSchema();
-  const db = getDb();
+): Promise<PatternComplianceResult> {
+  await initSchema();
   const result: PatternComplianceResult = { passed: true, violations: [], checked: 0 };
 
   if (files.length === 0) return result;
 
-  const allPatterns = db.query(
-    "SELECT * FROM implementation_patterns WHERE confidence >= ?"
-  ).all(minConfidence) as any[];
+  const allPatterns = await dbAll<any>(
+    "SELECT * FROM implementation_patterns WHERE confidence >= ?",
+    [minConfidence]
+  );
 
   if (allPatterns.length === 0) return result;
 
@@ -504,10 +491,9 @@ export function validatePatternCompliance(
       let structure: any;
       try { structure = JSON.parse(pattern.structure); } catch { continue; }
 
-      // Semantic patterns (source: "semantic") — use grepai if available
       if (structure.source === "semantic") {
         if (isGrepaiAvailable()) {
-          const ws = getGrepaiWorkspace() || undefined;
+          const ws = await getGrepaiWorkspace() || undefined;
           const grepaiResults = searchWithGrepai(
             `file:${file} follows ${pattern.category} pattern`, 1, ws
           );
@@ -522,7 +508,6 @@ export function validatePatternCompliance(
         continue;
       }
 
-      // Structural patterns — check imports, hooks, conventions
       if (structure.requiredImports) {
         for (const imp of structure.requiredImports) {
           if (!analysis.imports.includes(imp)) {

package/commands/plan.ts

@@ -1,4 +1,4 @@
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema, getArchitecturalAnalysisForSpec } from "../db/schema";
 import { resolveSpec } from "./spec-resolver";
 import { CodexaError, ValidationError } from "../errors";
@@ -154,16 +154,16 @@ export function generateSpecId(name: string): string {
 
 // v8.4: Suporte a --from-analysis para import automatico de baby steps
 // v9.9: Suporte a fases com budget calculator e auto-split
-export function planStart(description: string, options: { fromAnalysis?: string; json?: boolean; maxTasksPerPhase?: number } = {}): void {
-    initSchema();
-    const db = getDb();
+export async function planStart(description: string, options: { fromAnalysis?: string; json?: boolean; maxTasksPerPhase?: number } = {}): Promise<void> {
+    await initSchema();
 
     // v8.4: Buscar analise arquitetural se --from-analysis fornecido
     let analysis: any = null;
     if (options.fromAnalysis) {
-        analysis = db.query(
-            "SELECT * FROM architectural_analyses WHERE id = ?"
-        ).get(options.fromAnalysis) as any;
+        analysis = await dbGet<any>(
+            "SELECT * FROM architectural_analyses WHERE id = ?",
+            [options.fromAnalysis]
+        );
 
         if (!analysis) {
             if (options.json) {
@@ -186,7 +186,7 @@ export function planStart(description: string, options: { fromAnalysis?: string;
     } else {
         // v8.4: Auto-deteccao por nome
         // v10.0: Alertar se analise aprovada existe mas --from-analysis nao foi usado
-        const match = getArchitecturalAnalysisForSpec(description);
+        const match = await getArchitecturalAnalysisForSpec(description);
         if (match && match.status === "approved") {
             const msg = `Analise arquitetural aprovada encontrada: ${match.id} (${match.name}).\n`
                 + `Use: plan start "${description}" --from-analysis ${match.id}`;
@@ -215,19 +215,19 @@ export function planStart(description: string, options: { fromAnalysis?: string;
 
     // Criar spec (com analysis_id se disponivel)
     if (analysis) {
-        db.run(
+        await dbRun(
             "INSERT INTO specs (id, name, phase, analysis_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
             [specId, description, "planning", analysis.id, now, now]
         );
     } else {
-        db.run(
+        await dbRun(
             "INSERT INTO specs (id, name, phase, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
             [specId, description, "planning", now, now]
         );
     }
 
     // Criar contexto inicial
-    db.run(
+    await dbRun(
         "INSERT INTO context (spec_id, objective, updated_at) VALUES (?, ?, ?)",
         [specId, description, now]
     );
@@ -266,7 +266,7 @@ export function planStart(description: string, options: { fromAnalysis?: string;
                 const phase = phaseMap.get(step.number) || 1;
 
                 const normalizedStepAgent = step.agent ? resolveAgentName(step.agent) : null;
-                db.run(
+                await dbRun(
                     `INSERT INTO tasks (spec_id, number, name, agent, depends_on, can_parallel, files, phase)
                      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
                     [specId, step.number, step.name, normalizedStepAgent, dependsOn, 1, files, phase]
@@ -275,13 +275,13 @@ export function planStart(description: string, options: { fromAnalysis?: string;
             }
 
             // Atualizar total de tasks e fases no contexto
-            db.run(
+            await dbRun(
                 "UPDATE context SET total_tasks = ?, total_phases = ?, current_phase = 1, updated_at = ? WHERE spec_id = ?",
                 [tasksCreated, totalPhases, now, specId]
             );
 
             // Marcar analise como implemented
-            db.run(
+            await dbRun(
                 "UPDATE architectural_analyses SET status = 'implemented', updated_at = ? WHERE id = ?",
                 [now, analysis.id]
             );
@@ -301,8 +301,8 @@ export function planStart(description: string, options: { fromAnalysis?: string;
                 console.error(`\n[ERRO] ${msg}\n`);
             }
             // Cleanup: remover spec vazio criado
-            db.run("DELETE FROM context WHERE spec_id = ?", [specId]);
-            db.run("DELETE FROM specs WHERE id = ?", [specId]);
+            await dbRun("DELETE FROM context WHERE spec_id = ?", [specId]);
+            await dbRun("DELETE FROM specs WHERE id = ?", [specId]);
             throw new CodexaError(msg);
         }
     }
@@ -341,7 +341,7 @@ export function planStart(description: string, options: { fromAnalysis?: string;
                     console.log(`\n    Plano dividido em ${totalPhases} fases:`);
                     // Count tasks per phase
                     const tasksByPhase = new Map<number, number>();
-                    const allTasks = db.query("SELECT phase FROM tasks WHERE spec_id = ?").all(specId) as any[];
+                    const allTasks = await dbAll<any>("SELECT phase FROM tasks WHERE spec_id = ?", [specId]);
                     for (const t of allTasks) {
                         tasksByPhase.set(t.phase || 1, (tasksByPhase.get(t.phase || 1) || 0) + 1);
                     }
@@ -367,19 +367,20 @@ export function planStart(description: string, options: { fromAnalysis?: string;
     }
 }
 
-export function planShow(json: boolean = false, specId?: string): void {
-    initSchema();
-    const db = getDb();
+export async function planShow(json: boolean = false, specId?: string): Promise<void> {
+    await initSchema();
 
     const spec = resolveSpec(specId);
 
-    const tasks = db
-        .query("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number")
-        .all(spec.id) as any[];
+    const tasks = await dbAll<any>(
+        "SELECT * FROM tasks WHERE spec_id = ? ORDER BY number",
+        [spec.id]
+    );
 
-    const context = db
-        .query("SELECT * FROM context WHERE spec_id = ?")
-        .get(spec.id) as any;
+    const context = await dbGet<any>(
+        "SELECT * FROM context WHERE spec_id = ?",
+        [spec.id]
+    );
 
     if (json) {
         console.log(JSON.stringify({ spec, context, tasks }, null, 2));
@@ -450,23 +451,23 @@ function printTaskLine(task: any): void {
     console.log(`${statusIcon} #${task.number}: ${task.name} (${task.agent || "geral"})${depsStr}${parallelStr}`);
 }
 
-export function planTaskAdd(options: {
+export async function planTaskAdd(options: {
     name: string;
     agent?: string;
     depends?: string;
     files?: string;
     sequential?: boolean;
     specId?: string;
-}): void {
-    initSchema();
-    const db = getDb();
+}): Promise<void> {
+    await initSchema();
 
     const spec = resolveSpec(options.specId, ["planning"]);
 
     // Pegar proximo numero
-    const lastTask = db
-        .query("SELECT MAX(number) as max FROM tasks WHERE spec_id = ?")
-        .get(spec.id) as any;
+    const lastTask = await dbGet<any>(
+        "SELECT MAX(number) as max FROM tasks WHERE spec_id = ?",
+        [spec.id]
+    );
     const nextNumber = (lastTask?.max || 0) + 1;
 
     // Validar dependencias
@@ -474,9 +475,10 @@ export function planTaskAdd(options: {
     if (options.depends) {
         dependsOn = options.depends.split(",").map((s) => parseInt(s.trim()));
         for (const depId of dependsOn) {
-            const exists = db
-                .query("SELECT id FROM tasks WHERE spec_id = ? AND number = ?")
-                .get(spec.id, depId);
+            const exists = await dbGet(
+                "SELECT id FROM tasks WHERE spec_id = ? AND number = ?",
+                [spec.id, depId]
+            );
             if (!exists) {
                 throw new ValidationError(`Dependencia invalida: task #${depId} nao existe.`);
             }
@@ -484,9 +486,10 @@ export function planTaskAdd(options: {
 
         // v8.1: Detectar dependencias circulares
         // Construir grafo de dependencias e verificar se adicionar esta task cria ciclo
-        const allTasks = db
-            .query("SELECT number, depends_on FROM tasks WHERE spec_id = ?")
-            .all(spec.id) as any[];
+        const allTasks = await dbAll<any>(
+            "SELECT number, depends_on FROM tasks WHERE spec_id = ?",
+            [spec.id]
+        );
 
         // Grafo: taskNumber -> [dependencias]
         const graph = new Map<number, number[]>();
@@ -553,7 +556,7 @@ export function planTaskAdd(options: {
         files = options.files.split(",").map((s) => s.trim());
     }
 
-    db.run(
+    await dbRun(
         `INSERT INTO tasks (spec_id, number, name, agent, depends_on, can_parallel, files)
      VALUES (?, ?, ?, ?, ?, ?, ?)`,
         [
@@ -568,9 +571,9 @@ export function planTaskAdd(options: {
     );
 
     // Atualizar total de tasks no contexto
-    const count = db.query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?").get(spec.id) as any;
-    db.run("UPDATE context SET total_tasks = ?, updated_at = ? WHERE spec_id = ?", [
-        count.c,
+    const count = await dbGet<any>("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?", [spec.id]);
+    await dbRun("UPDATE context SET total_tasks = ?, updated_at = ? WHERE spec_id = ?", [
+        count?.c || 0,
         new Date().toISOString(),
         spec.id,
     ]);
@@ -582,22 +585,21 @@ export function planTaskAdd(options: {
     console.log(`  Paralelizavel: ${options.sequential ? "Nao" : "Sim"}\n`);
 }
 
-export function planCancel(specId?: string): void {
-    initSchema();
-    const db = getDb();
+export async function planCancel(specId?: string): Promise<void> {
+    await initSchema();
 
     const spec = resolveSpec(specId);
 
     const now = new Date().toISOString();
 
     // Marcar spec como cancelled
-    db.run(
+    await dbRun(
         "UPDATE specs SET phase = 'cancelled', updated_at = ? WHERE id = ?",
         [now, spec.id]
     );
 
     // Marcar tasks pendentes/running como cancelled
-    const updatedTasks = db.run(
+    const updatedTasks = await dbRun(
         "UPDATE tasks SET status = 'cancelled' WHERE spec_id = ? AND status IN ('pending', 'running')",
         [spec.id]
     );