@codexa/cli 9.0.31 → 9.0.32

package/commands/knowledge.ts

@@ -1,4 +1,4 @@
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema, getRelatedDecisions, getRelatedFiles } from "../db/schema";
 import { resolveSpec } from "./spec-resolver";
 import { CodexaError, ValidationError } from "../errors";
@@ -15,22 +15,21 @@ interface AddKnowledgeOptions {
   specId?: string;
 }
 
-function getCurrentTask(specId: string): any {
-  const db = getDb();
-  return db
-    .query("SELECT * FROM tasks WHERE spec_id = ? AND status = 'running' LIMIT 1")
-    .get(specId);
+async function getCurrentTask(specId: string): Promise<any> {
+  return await dbGet<any>(
+    "SELECT * FROM tasks WHERE spec_id = ? AND status = 'running' LIMIT 1",
+    [specId]
+  );
 }
 
-export function addKnowledge(options: AddKnowledgeOptions): void {
-  initSchema();
+export async function addKnowledge(options: AddKnowledgeOptions): Promise<void> {
+  await initSchema();
 
-  const db = getDb();
   const now = new Date().toISOString();
 
   const spec = resolveSpec(options.specId);
 
-  const currentTask = getCurrentTask(spec.id);
+  const currentTask = await getCurrentTask(spec.id);
   if (!currentTask) {
     throw new CodexaError("Nenhuma task em execucao.\nKnowledge so pode ser adicionado durante execucao de uma task.");
   }
@@ -43,7 +42,7 @@ export function addKnowledge(options: AddKnowledgeOptions): void {
   const severity = options.severity || "info";
   const broadcastTo = options.broadcastTo || "all";
 
-  db.run(
+  await dbRun(
     `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?)`,
     [spec.id, currentTask.id, options.category, options.content, severity, broadcastTo, now]
@@ -63,16 +62,14 @@ export function addKnowledge(options: AddKnowledgeOptions): void {
   console.log(`Conteudo: ${options.content}\n`);
 }
 
-export function listKnowledge(options: {
+export async function listKnowledge(options: {
   unread?: boolean;
   category?: string;
   severity?: string;  // v8.0: Filtro por severidade
   json?: boolean;
   specId?: string;
-}): void {
-  initSchema();
-
-  const db = getDb();
+}): Promise<void> {
+  await initSchema();
 
   const spec = resolveSpec(options.specId);
 
@@ -96,19 +93,22 @@ export function listKnowledge(options: {
 
   query += " ORDER BY severity DESC, created_at DESC";
 
-  const knowledge = db.query(query).all(...params) as any[];
+  const knowledge = await dbAll<any>(query, params);
 
   // Filtrar unread se solicitado
   let filtered = knowledge;
   if (options.unread) {
-    const currentTask = getCurrentTask(spec.id);
+    const currentTask = await getCurrentTask(spec.id);
     if (currentTask) {
-      filtered = knowledge.filter((k) => {
-        const isAcked = db.query(
-          "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?"
-        ).get(k.id, currentTask.id);
-        return !isAcked;
-      });
+      const filteredResults: any[] = [];
+      for (const k of knowledge) {
+        const isAcked = await dbGet(
+          "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?",
+          [k.id, currentTask.id]
+        );
+        if (!isAcked) filteredResults.push(k);
+      }
+      filtered = filteredResults;
     }
   }
 
@@ -141,26 +141,24 @@ export function listKnowledge(options: {
   }
 }
 
-export function acknowledgeKnowledge(knowledgeId: string, specId?: string): void {
-  initSchema();
-
-  const db = getDb();
+export async function acknowledgeKnowledge(knowledgeId: string, specId?: string): Promise<void> {
+  await initSchema();
 
   const spec = resolveSpec(specId);
 
-  const currentTask = getCurrentTask(spec.id);
+  const currentTask = await getCurrentTask(spec.id);
   if (!currentTask) {
     throw new CodexaError("Nenhuma task em execucao.");
   }
 
   const kid = parseInt(knowledgeId);
-  const knowledge = db.query("SELECT * FROM knowledge WHERE id = ?").get(kid) as any;
+  const knowledge = await dbGet<any>("SELECT * FROM knowledge WHERE id = ?", [kid]);
 
   if (!knowledge) {
     throw new CodexaError(`Knowledge #${kid} nao encontrado.`);
   }
 
-  db.run(
+  await dbRun(
     "INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)",
     [kid, currentTask.id]
   );
@@ -168,19 +166,16 @@ export function acknowledgeKnowledge(knowledgeId: string, specId?: string): void
   console.log(`\nKnowledge #${kid} marcado como lido pela Task #${currentTask.number}.\n`);
 }
 
-export function getKnowledgeForTask(specId: string, taskId: number): any[] {
-  const db = getDb();
-
+export async function getKnowledgeForTask(specId: string, taskId: number): Promise<any[]> {
   // Knowledge do spec atual (todas as severities)
   // Fix: LIKE '%taskId%' causava substring match (taskId=1 matchava "1,10,11")
-  const specKnowledge = db
-    .query(
-      `SELECT * FROM knowledge
-       WHERE spec_id = ?
-       ORDER BY severity DESC, created_at DESC
-       LIMIT 50`
-    )
-    .all(specId) as any[];
+  const specKnowledge = await dbAll<any>(
+    `SELECT * FROM knowledge
+     WHERE spec_id = ?
+     ORDER BY severity DESC, created_at DESC
+     LIMIT 50`,
+    [specId]
+  );
 
   const filtered = specKnowledge.filter((k) => {
     if (k.broadcast_to === 'all') return true;
@@ -189,14 +184,13 @@ export function getKnowledgeForTask(specId: string, taskId: number): any[] {
   });
 
   // Cross-feature: knowledge critical de outros specs (aprendizado global)
-  const crossFeature = db
-    .query(
-      `SELECT * FROM knowledge
-       WHERE spec_id != ? AND severity = 'critical'
-       ORDER BY created_at DESC
-       LIMIT 10`
-    )
-    .all(specId) as any[];
+  const crossFeature = await dbAll<any>(
+    `SELECT * FROM knowledge
+     WHERE spec_id != ? AND severity = 'critical'
+     ORDER BY created_at DESC
+     LIMIT 10`,
+    [specId]
+  );
 
   // Deduplicar por content (priorizar o do spec atual)
   const seenContent = new Set(filtered.map((k) => k.content));
@@ -205,34 +199,35 @@ export function getKnowledgeForTask(specId: string, taskId: number): any[] {
   return [...filtered, ...uniqueCross].slice(0, 25);
 }
 
-export function getUnreadKnowledgeForTask(specId: string, taskId: number): any[] {
-  const all = getKnowledgeForTask(specId, taskId);
-  const db = getDb();
+export async function getUnreadKnowledgeForTask(specId: string, taskId: number): Promise<any[]> {
+  const all = await getKnowledgeForTask(specId, taskId);
 
-  return all.filter((k) => {
-    const isAcked = db.query(
-      "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?"
-    ).get(k.id, taskId);
-    return !isAcked;
-  });
+  const results: any[] = [];
+  for (const k of all) {
+    const isAcked = await dbGet(
+      "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?",
+      [k.id, taskId]
+    );
+    if (!isAcked) results.push(k);
+  }
+  return results;
 }
 
 // v8.1: Consultar knowledge_graph - encontrar relacoes para arquivo, decisao ou pattern
-export function queryGraph(options: {
+export async function queryGraph(options: {
   file?: string;
   decision?: string;
   json?: boolean;
   specId?: string;
-}): void {
-  initSchema();
-  const db = getDb();
+}): Promise<void> {
+  await initSchema();
 
   const spec = resolveSpec(options.specId);
 
   // Buscar relacoes para um arquivo
   if (options.file) {
-    const decisions = getRelatedDecisions(options.file, "file");
-    const relatedFiles = db.query(`
+    const decisions = await getRelatedDecisions(options.file, "file");
+    const relatedFiles = await dbAll<any>(`
       SELECT DISTINCT kg.target_id as file, kg.relation
       FROM knowledge_graph kg
       WHERE kg.source_id = ? AND kg.target_type = 'file'
@@ -240,7 +235,7 @@ export function queryGraph(options: {
       SELECT DISTINCT kg.source_id as file, kg.relation
       FROM knowledge_graph kg
       WHERE kg.target_id = ? AND kg.source_type = 'file'
-    `).all(options.file, options.file) as any[];
+    `, [options.file, options.file]);
 
     if (options.json) {
       console.log(JSON.stringify({ file: options.file, decisions, relatedFiles }));
@@ -273,7 +268,7 @@ export function queryGraph(options: {
 
   // Buscar arquivos afetados por uma decisao
   if (options.decision) {
-    const files = getRelatedFiles(options.decision, "decision");
+    const files = await getRelatedFiles(options.decision, "decision");
 
     if (options.json) {
       console.log(JSON.stringify({ decision: options.decision, files }));
@@ -294,20 +289,22 @@ export function queryGraph(options: {
   }
 
   // Sem opcao: mostrar resumo do grafo
-  const totalRelations = db.query(
-    "SELECT COUNT(*) as c FROM knowledge_graph WHERE spec_id = ?"
-  ).get(spec.id) as any;
+  const totalRelations = await dbGet<any>(
+    "SELECT COUNT(*) as c FROM knowledge_graph WHERE spec_id = ?",
+    [spec.id]
+  );
 
-  const relationTypes = db.query(
-    "SELECT relation, COUNT(*) as c FROM knowledge_graph WHERE spec_id = ? GROUP BY relation ORDER BY c DESC"
-  ).all(spec.id) as any[];
+  const relationTypes = await dbAll<any>(
+    "SELECT relation, COUNT(*) as c FROM knowledge_graph WHERE spec_id = ? GROUP BY relation ORDER BY c DESC",
+    [spec.id]
+  );
 
   if (options.json) {
-    console.log(JSON.stringify({ totalRelations: totalRelations.c, relationTypes }));
+    console.log(JSON.stringify({ totalRelations: totalRelations?.c, relationTypes }));
     return;
   }
 
-  console.log(`\nKnowledge Graph: ${totalRelations.c} relacoes`);
+  console.log(`\nKnowledge Graph: ${totalRelations?.c} relacoes`);
   console.log(`${"─".repeat(50)}`);
   if (relationTypes.length > 0) {
     for (const rt of relationTypes) {
@@ -348,13 +345,12 @@ export function jaccardSimilarity(a: string, b: string): number {
 }
 
 // v9.2: Knowledge compaction — merge similar, archive old, archive completed
-export function compactKnowledge(options: {
+export async function compactKnowledge(options: {
   specId?: string;
   dryRun?: boolean;
   json?: boolean;
-}): void {
-  initSchema();
-  const db = getDb();
+}): Promise<void> {
+  await initSchema();
 
   let merged = 0;
   let archivedOld = 0;
@@ -366,11 +362,10 @@ export function compactKnowledge(options: {
     : "";
   const specParams = options.specId ? [options.specId] : [];
 
-  const entries = db
-    .query(
-      `SELECT * FROM knowledge WHERE severity != 'archived' ${specFilter} ORDER BY category, spec_id, created_at DESC`
-    )
-    .all(...specParams) as any[];
+  const entries = await dbAll<any>(
+    `SELECT * FROM knowledge WHERE severity != 'archived' ${specFilter} ORDER BY category, spec_id, created_at DESC`,
+    specParams
+  );
 
   // Group by category + spec_id
   const groups = new Map<string, any[]>();
@@ -403,20 +398,19 @@ export function compactKnowledge(options: {
 
   // Phase 2: Archive old info entries (>7 days, no graph references)
   const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
-  const oldInfoEntries = db
-    .query(
-      `SELECT k.id FROM knowledge k
-       WHERE k.severity = 'info' AND k.created_at < ? ${specFilter}
-       AND NOT EXISTS (
-         SELECT 1 FROM knowledge_graph kg
-         WHERE kg.source_id = CAST(k.id AS TEXT) AND kg.source_type = 'knowledge'
-       )
-       AND NOT EXISTS (
-         SELECT 1 FROM knowledge_graph kg
-         WHERE kg.target_id = CAST(k.id AS TEXT) AND kg.target_type = 'knowledge'
-       )`
-    )
-    .all(sevenDaysAgo, ...specParams) as any[];
+  const oldInfoEntries = await dbAll<any>(
+    `SELECT k.id FROM knowledge k
+     WHERE k.severity = 'info' AND k.created_at < ? ${specFilter}
+     AND NOT EXISTS (
+       SELECT 1 FROM knowledge_graph kg
+       WHERE kg.source_id = CAST(k.id AS TEXT) AND kg.source_type = 'knowledge'
+     )
+     AND NOT EXISTS (
+       SELECT 1 FROM knowledge_graph kg
+       WHERE kg.target_id = CAST(k.id AS TEXT) AND kg.target_type = 'knowledge'
+     )`,
+    [sevenDaysAgo, ...specParams]
+  );
 
   for (const entry of oldInfoEntries) {
     if (!toArchive.has(entry.id)) {
@@ -426,15 +420,14 @@ export function compactKnowledge(options: {
   }
 
   // Phase 3: Archive all entries from completed/cancelled specs
-  const completedEntries = db
-    .query(
-      `SELECT k.id FROM knowledge k
-       JOIN specs s ON k.spec_id = s.id
-       WHERE s.phase IN ('completed', 'cancelled')
-       AND k.severity != 'archived'
-       ${options.specId ? "AND k.spec_id = ?" : ""}`
-    )
-    .all(...specParams) as any[];
+  const completedEntries = await dbAll<any>(
+    `SELECT k.id FROM knowledge k
+     JOIN specs s ON k.spec_id = s.id
+     WHERE s.phase IN ('completed', 'cancelled')
+     AND k.severity != 'archived'
+     ${options.specId ? "AND k.spec_id = ?" : ""}`,
+    specParams
+  );
 
   for (const entry of completedEntries) {
     if (!toArchive.has(entry.id)) {
@@ -447,7 +440,7 @@ export function compactKnowledge(options: {
   if (!options.dryRun && toArchive.size > 0) {
     const ids = Array.from(toArchive);
     const placeholders = ids.map(() => "?").join(",");
-    db.run(
+    await dbRun(
       `UPDATE knowledge SET severity = 'archived' WHERE id IN (${placeholders})`,
       ids
     );
@@ -481,9 +474,8 @@ export function compactKnowledge(options: {
 }
 
 // v9.0: Resolver/reconhecer knowledge critico (para desbloquear task start)
-export function resolveKnowledge(ids: string, resolution?: string, specId?: string): void {
-  initSchema();
-  const db = getDb();
+export async function resolveKnowledge(ids: string, resolution?: string, specId?: string): Promise<void> {
+  await initSchema();
   const now = new Date().toISOString();
 
   const spec = resolveSpec(specId);
@@ -491,7 +483,7 @@ export function resolveKnowledge(ids: string, resolution?: string, specId?: stri
   const knowledgeIds = ids.split(",").map(s => parseInt(s.trim()));
 
   for (const kid of knowledgeIds) {
-    const knowledge = db.query("SELECT * FROM knowledge WHERE id = ?").get(kid) as any;
+    const knowledge = await dbGet<any>("SELECT * FROM knowledge WHERE id = ?", [kid]);
 
     if (!knowledge) {
       console.error(`Knowledge #${kid} nao encontrado.`);
@@ -499,7 +491,7 @@ export function resolveKnowledge(ids: string, resolution?: string, specId?: stri
     }
 
     // Usar -1 como marker de "resolvido pelo orquestrador"
-    db.run(
+    await dbRun(
       "INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)",
       [kid, -1]
     );
@@ -508,7 +500,7 @@ export function resolveKnowledge(ids: string, resolution?: string, specId?: stri
   }
 
   if (resolution) {
-    db.run(
+    await dbRun(
       `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
        VALUES (?, 0, 'decision', ?, 'info', 'all', ?)`,
       [spec.id, `Resolucao de blockers: ${resolution}`, now]
@@ -520,15 +512,14 @@ export function resolveKnowledge(ids: string, resolution?: string, specId?: stri
 }
 
 // v10.0: Compact reasoning_log during phase advance
-export function compactReasoning(options: {
+export async function compactReasoning(options: {
   specId: string | number;
   dryRun?: boolean;
-}): { archived: number; kept: number } {
-  const db = getDb();
-
-  const doneTasks = db.query(
-    "SELECT id FROM tasks WHERE spec_id = ? AND status = 'done'"
-  ).all(options.specId) as any[];
+}): Promise<{ archived: number; kept: number }> {
+  const doneTasks = await dbAll<any>(
+    "SELECT id FROM tasks WHERE spec_id = ? AND status = 'done'",
+    [options.specId]
+  );
 
   if (doneTasks.length === 0) return { archived: 0, kept: 0 };
 
@@ -536,23 +527,25 @@ export function compactReasoning(options: {
   const placeholders = doneTaskIds.map(() => "?").join(",");
 
   // Phase 1: Remove low-importance entries from completed tasks (keep recommendations always)
-  const lowImportance = db.query(
+  const lowImportance = await dbAll<any>(
     `SELECT id FROM reasoning_log
      WHERE spec_id = ? AND task_id IN (${placeholders})
      AND importance IN ('normal', 'low')
-     AND category != 'recommendation'`
-  ).all(options.specId, ...doneTaskIds) as any[];
+     AND category != 'recommendation'`,
+    [options.specId, ...doneTaskIds]
+  );
 
   // Phase 2: Cap at 5 entries per task (keep most important)
   const overflow: number[] = [];
   for (const taskId of doneTaskIds) {
-    const entries = db.query(
+    const entries = await dbAll<any>(
       `SELECT id FROM reasoning_log
        WHERE spec_id = ? AND task_id = ?
        ORDER BY
          CASE importance WHEN 'critical' THEN 1 WHEN 'high' THEN 2 WHEN 'normal' THEN 3 ELSE 4 END,
-         created_at DESC`
-    ).all(options.specId, taskId) as any[];
+         created_at DESC`,
+      [options.specId, taskId]
+    );
 
     if (entries.length > 5) {
       for (let i = 5; i < entries.length; i++) {
@@ -569,12 +562,14 @@ export function compactReasoning(options: {
   if (!options.dryRun && archiveIds.size > 0) {
     const ids = Array.from(archiveIds);
     const ph = ids.map(() => "?").join(",");
-    db.run(`DELETE FROM reasoning_log WHERE id IN (${ph})`, ids);
+    await dbRun(`DELETE FROM reasoning_log WHERE id IN (${ph})`, ids);
   }
 
-  const kept = (db.query(
-    "SELECT COUNT(*) as c FROM reasoning_log WHERE spec_id = ?"
-  ).get(options.specId) as any)?.c || 0;
+  const keptRow = await dbGet<any>(
+    "SELECT COUNT(*) as c FROM reasoning_log WHERE spec_id = ?",
+    [options.specId]
+  );
+  const kept = keptRow?.c || 0;
 
   return { archived: archiveIds.size, kept };
 }