@codexa/cli 9.0.31 → 9.0.32

package/commands/architect.ts

@@ -1,4 +1,4 @@
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
 import { CodexaError } from "../errors";
@@ -48,34 +48,26 @@ interface ArchitecturalAnalysis {
   description: string;
   status: "pending" | "approved" | "implemented" | "rejected";
 
-  // Contexto
   context: string;
   currentArchitecture: string;
 
-  // Solucao
   approach: string;
   chosenAlternative: string;
 
-  // Diagramas (Mermaid)
   diagrams: {
     name: string;
     type: string;
     content: string;
   }[];
 
-  // Baby Steps
   babySteps: BabyStep[];
 
-  // Riscos
   risks: Risk[];
 
-  // Alternativas
   alternatives: Alternative[];
 
-  // Decisoes
   decisions: ArchitecturalDecision[];
 
-  // Metadados
   filePath?: string;
   createdAt: string;
   updatedAt?: string;
@@ -145,7 +137,6 @@ const HEADER_ALIASES: Record<string, string[]> = {
 export function extractSection(content: string, header: string): string {
   const sections = content.split(/^## /m);
 
-  // Tier 1: Exact startsWith (fast path)
   for (const section of sections) {
     if (section.startsWith(header)) {
       const lines = section.split("\n");
@@ -153,7 +144,6 @@ export function extractSection(content: string, header: string): string {
     }
   }
 
-  // Tier 2: Case-insensitive startsWith
   const headerLower = header.toLowerCase();
   for (const section of sections) {
     if (section.toLowerCase().startsWith(headerLower)) {
@@ -162,7 +152,6 @@ export function extractSection(content: string, header: string): string {
     }
   }
 
-  // Tier 3: Alias-based includes matching (case-insensitive)
   const aliases = HEADER_ALIASES[header] || [];
   for (const section of sections) {
     const sectionHeader = section.split("\n")[0]?.toLowerCase().trim() || "";
@@ -182,7 +171,6 @@ export function parseBabySteps(section: string): BabyStep[] {
   if (!section) return [];
   const steps: BabyStep[] = [];
 
-  // Detect phase headers: "## Fase N:" or "## Phase N:"
   let currentPhase = 1;
   let hasExplicitPhases = false;
   const phaseRegex = /^##\s+(?:Fase|Phase)\s+(\d+)/im;
@@ -190,8 +178,6 @@ export function parseBabySteps(section: string): BabyStep[] {
     hasExplicitPhases = true;
   }
 
-  // Split by phase headers first, then by step headers
-  // We process the section line-by-line to track phase context
   const lines = section.split("\n");
   let currentBlock = "";
   let blockPhase = currentPhase;
@@ -199,7 +185,6 @@ export function parseBabySteps(section: string): BabyStep[] {
   for (const line of lines) {
     const phaseMatch = line.match(/^##\s+(?:Fase|Phase)\s+(\d+)/i);
     if (phaseMatch) {
-      // Process pending block BEFORE changing phase
       if (currentBlock.trim()) {
         const step = parseStepBlock(currentBlock, hasExplicitPhases ? blockPhase : undefined);
         if (step) steps.push(step);
@@ -210,7 +195,6 @@ export function parseBabySteps(section: string): BabyStep[] {
       continue;
     }
 
-    // When we hit a new step header, process the previous block
     if (line.match(/^###\s+/) && currentBlock.trim()) {
       const step = parseStepBlock(currentBlock, hasExplicitPhases ? blockPhase : undefined);
       if (step) steps.push(step);
@@ -221,7 +205,6 @@ export function parseBabySteps(section: string): BabyStep[] {
     }
   }
 
-  // Process the last block
   if (currentBlock.trim()) {
     const step = parseStepBlock(currentBlock, hasExplicitPhases ? blockPhase : undefined);
     if (step) steps.push(step);
@@ -231,7 +214,6 @@ export function parseBabySteps(section: string): BabyStep[] {
 }
 
 function parseStepBlock(block: string, phase?: number): BabyStep | null {
-  // Remove leading "### " prefix for matching
   const content = block.replace(/^###\s+/, "");
   const headerMatch = content.match(/^(?:Step\s+)?(\d+)[.:]\s*(.+)/);
   if (!headerMatch) return null;
@@ -306,12 +288,10 @@ export function parseDecisionsTable(section: string): ArchitecturalDecision[] {
   const lines = section.split("\n");
 
   for (const line of lines) {
-    // Match table rows: | Decision | Rationale |
     const rowMatch = line.match(/^\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|$/);
     if (!rowMatch) continue;
     const decision = rowMatch[1].trim();
     const rationale = rowMatch[2].trim();
-    // Skip header and separator rows
     if (decision === "Decisao" || decision.startsWith("---")) continue;
     if (decision && rationale) {
       decisions.push({ decision, rationale });
@@ -346,10 +326,6 @@ function parseAlternatives(section: string): Alternative[] {
   return alternatives;
 }
 
-/**
- * v8.4: Parseia um arquivo .md de analise arquitetural e extrai dados estruturados.
- * O .md deve seguir o template padrao do codexa:architect.
- */
 export function parseAnalysisMd(content: string): {
   context: string;
   currentArchitecture: string;
@@ -386,16 +362,15 @@ export function parseAnalysisMd(content: string): {
 // COMMANDS
 // ═══════════════════════════════════════════════════════════════
 
-export function architectStart(description: string, options: { json?: boolean } = {}): void {
-  initSchema();
-  const db = getDb();
+export async function architectStart(description: string, options: { json?: boolean } = {}): Promise<void> {
+  await initSchema();
   const now = new Date().toISOString();
   const id = generateId();
 
-  // Verificar se ja existe analise pendente
-  const pending = db.query(
-    "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1"
-  ).get() as any;
+  const pending = await dbGet<any>(
+    "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1",
+    []
+  );
 
   if (pending) {
     if (options.json) {
@@ -418,8 +393,7 @@ export function architectStart(description: string, options: { json?: boolean }
     throw new CodexaError("Ja existe uma analise pendente. Use 'architect show' ou 'architect cancel'.");
   }
 
-  // Criar nova analise
-  db.run(
+  await dbRun(
     `INSERT INTO architectural_analyses (id, name, description, status, created_at)
      VALUES (?, ?, ?, 'pending', ?)`,
     [id, description, description, now]
@@ -460,24 +434,24 @@ export function architectStart(description: string, options: { json?: boolean }
   }
 }
 
-export function architectShow(options: { id?: string; json?: boolean } = {}): void {
-  initSchema();
-  const db = getDb();
+export async function architectShow(options: { id?: string; json?: boolean } = {}): Promise<void> {
+  await initSchema();
 
   let analysis: any;
 
   if (options.id) {
-    analysis = db.query("SELECT * FROM architectural_analyses WHERE id = ?").get(options.id);
+    analysis = await dbGet<any>("SELECT * FROM architectural_analyses WHERE id = ?", [options.id]);
   } else {
-    // Pegar a mais recente pendente ou a ultima
-    analysis = db.query(
-      "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1"
-    ).get();
+    analysis = await dbGet<any>(
+      "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1",
+      []
+    );
 
     if (!analysis) {
-      analysis = db.query(
-        "SELECT * FROM architectural_analyses ORDER BY created_at DESC LIMIT 1"
-      ).get();
+      analysis = await dbGet<any>(
+        "SELECT * FROM architectural_analyses ORDER BY created_at DESC LIMIT 1",
+        []
+      );
     }
   }
 
@@ -491,7 +465,6 @@ export function architectShow(options: { id?: string; json?: boolean } = {}): vo
     return;
   }
 
-  // Parse JSON fields
   const parsed: ArchitecturalAnalysis = {
     id: analysis.id,
     name: analysis.name,
@@ -557,9 +530,8 @@ export function architectShow(options: { id?: string; json?: boolean } = {}): vo
   }
 }
 
-export function architectList(options: { json?: boolean; status?: string } = {}): void {
-  initSchema();
-  const db = getDb();
+export async function architectList(options: { json?: boolean; status?: string } = {}): Promise<void> {
+  await initSchema();
 
   let query = "SELECT id, name, status, created_at, file_path FROM architectural_analyses";
   const params: any[] = [];
@@ -571,7 +543,7 @@ export function architectList(options: { json?: boolean; status?: string } = {})
 
   query += " ORDER BY created_at DESC";
 
-  const analyses = db.query(query).all(...params) as any[];
+  const analyses = await dbAll<any>(query, params);
 
   if (options.json) {
     console.log(JSON.stringify(analyses, null, 2));
@@ -601,15 +573,14 @@ export function architectList(options: { json?: boolean; status?: string } = {})
   }
 }
 
-export function architectSave(options: { file?: string; json?: boolean }): void {
-  initSchema();
-  const db = getDb();
+export async function architectSave(options: { file?: string; json?: boolean }): Promise<void> {
+  await initSchema();
   const now = new Date().toISOString();
 
-  // Pegar analise pendente
-  const analysis = db.query(
-    "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1"
-  ).get() as any;
+  const analysis = await dbGet<any>(
+    "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1",
+    []
+  );
 
   if (!analysis) {
     if (options.json) {
@@ -620,17 +591,14 @@ export function architectSave(options: { file?: string; json?: boolean }): void
     throw new CodexaError("Nenhuma analise pendente encontrada.");
   }
 
-  // v8.4: Resolver caminho do arquivo .md
   const dir = ensureAnalysisDir();
   let filePath: string;
   if (options.file) {
-    // Se path fornecido, usar como-is (aceita absoluto ou relativo)
     filePath = options.file;
   } else {
     filePath = join(dir, `${analysis.id}-${analysis.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").substring(0, 30)}.md`);
   }
 
-  // v8.4: Ler .md do disco e parsear para popular o DB
   if (!existsSync(filePath)) {
     if (options.json) {
       console.log(JSON.stringify({ error: "FILE_NOT_FOUND", message: `Arquivo nao encontrado: ${filePath}` }));
@@ -644,7 +612,6 @@ export function architectSave(options: { file?: string; json?: boolean }): void
   const content = readFileSync(filePath, "utf-8");
   const parsed = parseAnalysisMd(content);
 
-  // v10.0: Validar secoes criticas antes de salvar
   if (!parsed.babySteps || parsed.babySteps.length === 0) {
     const msg = "Secao 'Baby Steps' esta vazia ou nao foi encontrada no .md. "
       + "Verifique se os headers seguem o formato '## Baby Steps' e cada step usa '### N. Nome'.";
@@ -667,7 +634,6 @@ export function architectSave(options: { file?: string; json?: boolean }): void
     throw new CodexaError(msg);
   }
 
-  // Popular DB com dados extraidos do .md
   const updates: string[] = [];
   const values: any[] = [];
 
@@ -710,7 +676,7 @@ export function architectSave(options: { file?: string; json?: boolean }): void
   values.push(now);
   values.push(analysis.id);
 
-  db.run(
+  await dbRun(
     `UPDATE architectural_analyses SET ${updates.join(", ")} WHERE id = ?`,
     values
   );
@@ -750,19 +716,19 @@ export function architectSave(options: { file?: string; json?: boolean }): void
   }
 }
 
-export function architectApprove(options: { id?: string; json?: boolean }): void {
-  initSchema();
-  const db = getDb();
+export async function architectApprove(options: { id?: string; json?: boolean }): Promise<void> {
+  await initSchema();
   const now = new Date().toISOString();
 
   let analysis: any;
 
   if (options.id) {
-    analysis = db.query("SELECT * FROM architectural_analyses WHERE id = ?").get(options.id);
+    analysis = await dbGet<any>("SELECT * FROM architectural_analyses WHERE id = ?", [options.id]);
   } else {
-    analysis = db.query(
-      "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1"
-    ).get();
+    analysis = await dbGet<any>(
+      "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1",
+      []
+    );
   }
 
   if (!analysis) {
@@ -783,7 +749,7 @@ export function architectApprove(options: { id?: string; json?: boolean }): void
     throw new CodexaError(`Analise ja esta com status '${analysis.status}'.`);
   }
 
-  db.run(
+  await dbRun(
     "UPDATE architectural_analyses SET status = 'approved', approved_at = ?, updated_at = ? WHERE id = ?",
     [now, now, analysis.id]
   );
@@ -802,19 +768,18 @@ export function architectApprove(options: { id?: string; json?: boolean }): void
   }
 }
 
-// v8.4: Simplificado - agora o feature importa baby steps automaticamente via --from-analysis
-export function architectExport(options: { id?: string; json?: boolean }): void {
-  initSchema();
-  const db = getDb();
+export async function architectExport(options: { id?: string; json?: boolean }): Promise<void> {
+  await initSchema();
 
   let analysis: any;
 
   if (options.id) {
-    analysis = db.query("SELECT * FROM architectural_analyses WHERE id = ?").get(options.id);
+    analysis = await dbGet<any>("SELECT * FROM architectural_analyses WHERE id = ?", [options.id]);
   } else {
-    analysis = db.query(
-      "SELECT * FROM architectural_analyses WHERE status = 'approved' ORDER BY approved_at DESC LIMIT 1"
-    ).get();
+    analysis = await dbGet<any>(
+      "SELECT * FROM architectural_analyses WHERE status = 'approved' ORDER BY approved_at DESC LIMIT 1",
+      []
+    );
   }
 
   if (!analysis) {
@@ -854,19 +819,19 @@ export function architectExport(options: { id?: string; json?: boolean }): void
   }
 }
 
-export function architectCancel(options: { id?: string; json?: boolean }): void {
-  initSchema();
-  const db = getDb();
+export async function architectCancel(options: { id?: string; json?: boolean }): Promise<void> {
+  await initSchema();
   const now = new Date().toISOString();
 
   let analysis: any;
 
   if (options.id) {
-    analysis = db.query("SELECT * FROM architectural_analyses WHERE id = ?").get(options.id);
+    analysis = await dbGet<any>("SELECT * FROM architectural_analyses WHERE id = ?", [options.id]);
   } else {
-    analysis = db.query(
-      "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1"
-    ).get();
+    analysis = await dbGet<any>(
+      "SELECT * FROM architectural_analyses WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1",
+      []
+    );
   }
 
   if (!analysis) {
@@ -878,7 +843,7 @@ export function architectCancel(options: { id?: string; json?: boolean }): void
     return;
   }
 
-  db.run(
+  await dbRun(
     "UPDATE architectural_analyses SET status = 'rejected', updated_at = ? WHERE id = ?",
     [now, analysis.id]
   );

package/commands/check.ts

@@ -1,25 +1,26 @@
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { enforceGate } from "../gates/validator";
 import { resolveSpec } from "./spec-resolver";
 
-export function checkRequest(specId?: string): void {
-  initSchema();
+export async function checkRequest(specId?: string): Promise<void> {
+  await initSchema();
   enforceGate("check-request");
 
-  const db = getDb();
   const spec = resolveSpec(specId, ["planning"]);
 
-  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]
+  );
 
   // Atualizar fase para checking
-  db.run("UPDATE specs SET phase = 'checking', updated_at = ? WHERE id = ?", [
+  await dbRun("UPDATE specs SET phase = 'checking', updated_at = ? WHERE id = ?", [
     new Date().toISOString(),
     spec.id,
   ]);
@@ -67,29 +68,28 @@ export function checkRequest(specId?: string): void {
   console.log(`Para ajustar: plan task-add (adiciona mais tasks)\n`);
 }
 
-export function checkApprove(specId?: string): void {
-  initSchema();
+export async function checkApprove(specId?: string): Promise<void> {
+  await initSchema();
   enforceGate("check-approve");
 
-  const db = getDb();
   const now = new Date().toISOString();
 
   const spec = resolveSpec(specId, ["checking"]);
 
   // Atualizar para aprovado
-  db.run(
+  await dbRun(
     "UPDATE specs SET phase = 'implementing', approved_at = ?, updated_at = ? WHERE id = ?",
     [now, now, spec.id]
   );
 
   // Atualizar contexto
-  db.run("UPDATE context SET current_task = 0, updated_at = ? WHERE spec_id = ?", [now, spec.id]);
+  await dbRun("UPDATE context SET current_task = 0, updated_at = ? WHERE spec_id = ?", [now, spec.id]);
 
-  const taskCount = db.query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?").get(spec.id) as any;
+  const taskCount = await dbGet<any>("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?", [spec.id]);
 
   console.log(`\nPlano APROVADO!`);
   console.log(`Feature: ${spec.name}`);
-  console.log(`Tasks: ${taskCount.c}`);
+  console.log(`Tasks: ${taskCount?.c || 0}`);
   console.log(`Fase: implementing`);
   console.log(`\nProximos passos:`);
   console.log(`1. Veja proximas tasks com: task next`);
@@ -97,19 +97,18 @@ export function checkApprove(specId?: string): void {
   console.log(`3. Complete uma task com: task done <id> --checkpoint "..."\n`);
 }
 
-export function checkReject(reason: string, specId?: string): void {
-  initSchema();
+export async function checkReject(reason: string, specId?: string): Promise<void> {
+  await initSchema();
 
-  const db = getDb();
   const now = new Date().toISOString();
 
   const spec = resolveSpec(specId, ["checking"]);
 
   // Voltar para planning
-  db.run("UPDATE specs SET phase = 'planning', updated_at = ? WHERE id = ?", [now, spec.id]);
+  await dbRun("UPDATE specs SET phase = 'planning', updated_at = ? WHERE id = ?", [now, spec.id]);
 
   // Registrar motivo no contexto
-  db.run(
+  await dbRun(
     "UPDATE context SET last_checkpoint = ?, updated_at = ? WHERE spec_id = ?",
     [`REJEITADO: ${reason}`, now, spec.id]
   );

package/commands/clear.ts

@@ -1,29 +1,37 @@
-import { getDbPath, getDb } from "../db/connection";
+import { dbGet, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { existsSync } from "fs";
-import { join, dirname } from "path";
+import { join } from "path";
 
 interface ClearOptions {
   force?: boolean;
   specId?: string;
 }
 
+function getDbUrl(): string {
+  return process.env.CODEXA_DB_URL || "(nao configurado)";
+}
+
 /**
  * Limpa apenas as tasks/features, mantendo configurações do projeto
  * Esta é a ÚNICA forma de limpeza disponível (v8.0)
  * A limpeza completa foi removida por ser muito destrutiva
  */
-export function clearTasks(options: ClearOptions = {}): void {
+export async function clearTasks(options: ClearOptions = {}): Promise<void> {
   // Garantir que o schema existe
-  initSchema();
-  const db = getDb();
+  await initSchema();
 
   // Contar o que existe
-  const specsCount = (db.query("SELECT COUNT(*) as c FROM specs").get() as any).c;
-  const tasksCount = (db.query("SELECT COUNT(*) as c FROM tasks").get() as any).c;
-  const decisionsCount = (db.query("SELECT COUNT(*) as c FROM decisions").get() as any).c;
-  const knowledgeCount = (db.query("SELECT COUNT(*) as c FROM knowledge").get() as any).c;
-  const reasoningCount = (db.query("SELECT COUNT(*) as c FROM reasoning_log").get() as any).c;
+  const specsRow = await dbGet<any>("SELECT COUNT(*) as c FROM specs", []);
+  const specsCount = specsRow?.c ?? 0;
+  const tasksRow = await dbGet<any>("SELECT COUNT(*) as c FROM tasks", []);
+  const tasksCount = tasksRow?.c ?? 0;
+  const decisionsRow = await dbGet<any>("SELECT COUNT(*) as c FROM decisions", []);
+  const decisionsCount = decisionsRow?.c ?? 0;
+  const knowledgeRow = await dbGet<any>("SELECT COUNT(*) as c FROM knowledge", []);
+  const knowledgeCount = knowledgeRow?.c ?? 0;
+  const reasoningRow = await dbGet<any>("SELECT COUNT(*) as c FROM reasoning_log", []);
+  const reasoningCount = reasoningRow?.c ?? 0;
 
   if (specsCount === 0 && tasksCount === 0) {
     console.log("\nNenhuma feature/task para limpar.\n");
@@ -87,7 +95,7 @@ export function clearTasks(options: ClearOptions = {}): void {
 
     for (const table of tablesWithSpecId) {
       try {
-        const result = db.run(`DELETE FROM ${table} WHERE spec_id = ?`, [options.specId]);
+        const result = await dbRun(`DELETE FROM ${table} WHERE spec_id = ?`, [options.specId]);
         if (result.changes > 0) {
           console.log(`  Limpo: ${table} (${result.changes} registros)`);
         }
@@ -126,7 +134,7 @@ export function clearTasks(options: ClearOptions = {}): void {
 
   for (const table of tablesToClear) {
     try {
-      const result = db.run(`DELETE FROM ${table}`);
+      const result = await dbRun(`DELETE FROM ${table}`);
       console.log(`  Limpo: ${table} (${result.changes} registros)`);
     } catch (err: any) {
       // Tabela pode não existir em bancos antigos
@@ -148,15 +156,9 @@ export function clearTasks(options: ClearOptions = {}): void {
 /**
  * Mostra o estado atual do workflow
  */
-export function clearShow(): void {
-  const dbPath = getDbPath();
-  const codexaDir = dirname(dirname(dbPath));
-
-  const dbFiles = [
-    dbPath,
-    `${dbPath}-shm`,
-    `${dbPath}-wal`,
-  ];
+export async function clearShow(): Promise<void> {
+  const codexaDir = join(process.cwd(), ".codexa");
+  const dbUrl = getDbUrl();
 
   const markdownFiles = [
     join(codexaDir, "standards.md"),
@@ -168,11 +170,7 @@ export function clearShow(): void {
   console.log("ESTADO DO WORKFLOW");
   console.log("═".repeat(60) + "\n");
 
-  console.log("Banco de dados:");
-  for (const file of dbFiles) {
-    const status = existsSync(file) ? "existe" : "nao existe";
-    console.log(`  ${file}: ${status}`);
-  }
+  console.log(`Banco de dados: ${dbUrl}`);
 
   console.log("\nArquivos gerados:");
   for (const file of markdownFiles) {
@@ -180,28 +178,24 @@ export function clearShow(): void {
     console.log(`  ${file}: ${status}`);
   }
 
-  // Mostrar estatísticas do banco se existir
-  if (existsSync(dbPath)) {
-    try {
-      initSchema();
-      const db = getDb();
-
-      console.log("\nEstatisticas:");
-
-      const specs = (db.query("SELECT COUNT(*) as c FROM specs").get() as any).c;
-      const tasks = (db.query("SELECT COUNT(*) as c FROM tasks").get() as any).c;
-      const decisions = (db.query("SELECT COUNT(*) as c FROM decisions").get() as any).c;
-      const standards = (db.query("SELECT COUNT(*) as c FROM standards").get() as any).c;
-      const patterns = (db.query("SELECT COUNT(*) as c FROM implementation_patterns").get() as any).c;
-
-      console.log(`  Features: ${specs}`);
-      console.log(`  Tasks: ${tasks}`);
-      console.log(`  Decisions: ${decisions}`);
-      console.log(`  Standards: ${standards}`);
-      console.log(`  Patterns: ${patterns}`);
-    } catch (err: any) {
-      console.log(`\n  Erro ao ler estatisticas: ${err.message}`);
-    }
+  try {
+    await initSchema();
+
+    console.log("\nEstatisticas:");
+
+    const specsRow = await dbGet<any>("SELECT COUNT(*) as c FROM specs", []);
+    const tasksRow = await dbGet<any>("SELECT COUNT(*) as c FROM tasks", []);
+    const decisionsRow = await dbGet<any>("SELECT COUNT(*) as c FROM decisions", []);
+    const standardsRow = await dbGet<any>("SELECT COUNT(*) as c FROM standards", []);
+    const patternsRow = await dbGet<any>("SELECT COUNT(*) as c FROM implementation_patterns", []);
+
+    console.log(`  Features: ${specsRow?.c ?? 0}`);
+    console.log(`  Tasks: ${tasksRow?.c ?? 0}`);
+    console.log(`  Decisions: ${decisionsRow?.c ?? 0}`);
+    console.log(`  Standards: ${standardsRow?.c ?? 0}`);
+    console.log(`  Patterns: ${patternsRow?.c ?? 0}`);
+  } catch (err: any) {
+    console.log(`\n  Erro ao ler estatisticas: ${err.message}`);
   }
 
   console.log("\n" + "─".repeat(60));