@codexa/cli 8.5.0

package/commands/check.ts

@@ -0,0 +1,131 @@
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+import { enforceGate } from "../gates/validator";
+
+export function checkRequest(): void {
+  initSchema();
+  enforceGate("check-request");
+
+  const db = getDb();
+  const spec = db
+    .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
+    .get() as any;
+
+  const tasks = db
+    .query("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number")
+    .all(spec.id) as any[];
+
+  const context = db
+    .query("SELECT * FROM context WHERE spec_id = ?")
+    .get(spec.id) as any;
+
+  // Atualizar fase para checking
+  db.run("UPDATE specs SET phase = 'checking', updated_at = ? WHERE id = ?", [
+    new Date().toISOString(),
+    spec.id,
+  ]);
+
+  // Exibir plano para aprovacao
+  console.log(`\n${"=".repeat(60)}`);
+  console.log(`SOLICITACAO DE APROVACAO`);
+  console.log(`${"=".repeat(60)}`);
+  console.log(`\nFeature: ${spec.name}`);
+  console.log(`Objetivo: ${context?.objective || "-"}`);
+  console.log(`\nTasks planejadas (${tasks.length}):`);
+  console.log(`${"─".repeat(60)}`);
+
+  // Identificar grupos paralelos
+  const groups: { parallel: any[]; sequential: any[] } = { parallel: [], sequential: [] };
+
+  for (const task of tasks) {
+    const deps = task.depends_on ? JSON.parse(task.depends_on) : [];
+    if (task.can_parallel && deps.length === 0) {
+      groups.parallel.push(task);
+    } else {
+      groups.sequential.push(task);
+    }
+  }
+
+  if (groups.parallel.length > 0) {
+    console.log(`\nGrupo paralelo (podem executar simultaneamente):`);
+    for (const task of groups.parallel) {
+      console.log(`  #${task.number}: ${task.name} (${task.agent || "geral"})`);
+    }
+  }
+
+  if (groups.sequential.length > 0) {
+    console.log(`\nTasks sequenciais:`);
+    for (const task of groups.sequential) {
+      const deps = task.depends_on ? JSON.parse(task.depends_on) : [];
+      const depsStr = deps.length > 0 ? ` [apos: ${deps.join(",")}]` : "";
+      console.log(`  #${task.number}: ${task.name} (${task.agent || "geral"})${depsStr}`);
+    }
+  }
+
+  console.log(`\n${"─".repeat(60)}`);
+  console.log(`\nPara aprovar: check approve`);
+  console.log(`Para rejeitar: check reject "motivo"`);
+  console.log(`Para ajustar: plan task-add (adiciona mais tasks)\n`);
+}
+
+export function checkApprove(): void {
+  initSchema();
+  enforceGate("check-approve");
+
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  const spec = db
+    .query("SELECT * FROM specs WHERE phase = 'checking' ORDER BY created_at DESC LIMIT 1")
+    .get() as any;
+
+  // Atualizar para aprovado
+  db.run(
+    "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]);
+
+  const taskCount = db.query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?").get(spec.id) as any;
+
+  console.log(`\nPlano APROVADO!`);
+  console.log(`Feature: ${spec.name}`);
+  console.log(`Tasks: ${taskCount.c}`);
+  console.log(`Fase: implementing`);
+  console.log(`\nProximos passos:`);
+  console.log(`1. Veja proximas tasks com: task next`);
+  console.log(`2. Inicie uma task com: task start <ids>`);
+  console.log(`3. Complete uma task com: task done <id> --checkpoint "..."\n`);
+}
+
+export function checkReject(reason: string): void {
+  initSchema();
+
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  const spec = db
+    .query("SELECT * FROM specs WHERE phase = 'checking' ORDER BY created_at DESC LIMIT 1")
+    .get() as any;
+
+  if (!spec) {
+    console.error("\nNenhum plano aguardando aprovacao.\n");
+    process.exit(1);
+  }
+
+  // Voltar para planning
+  db.run("UPDATE specs SET phase = 'planning', updated_at = ? WHERE id = ?", [now, spec.id]);
+
+  // Registrar motivo no contexto
+  db.run(
+    "UPDATE context SET last_checkpoint = ?, updated_at = ? WHERE spec_id = ?",
+    [`REJEITADO: ${reason}`, now, spec.id]
+  );
+
+  console.log(`\nPlano REJEITADO.`);
+  console.log(`Motivo: ${reason}`);
+  console.log(`\nFase retornada para: planning`);
+  console.log(`Ajuste o plano e solicite nova aprovacao com: check request\n`);
+}

package/commands/clear.ts

@@ -0,0 +1,174 @@
+import { getDbPath, getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+
+interface ClearOptions {
+  force?: boolean;
+}
+
+/**
+ * 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 {
+  // Garantir que o schema existe
+  initSchema();
+  const db = getDb();
+
+  // 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;
+
+  if (specsCount === 0 && tasksCount === 0) {
+    console.log("\nNenhuma feature/task para limpar.\n");
+    return;
+  }
+
+  if (!options.force) {
+    console.log("\n" + "═".repeat(60));
+    console.log("CODEXA WORKFLOW - LIMPEZA DE TASKS");
+    console.log("═".repeat(60));
+
+    console.log("\nO seguinte sera PERMANENTEMENTE removido:\n");
+    console.log(`  - ${specsCount} feature(s)`);
+    console.log(`  - ${tasksCount} task(s)`);
+    console.log(`  - ${decisionsCount} decisao(oes)`);
+    console.log(`  - ${knowledgeCount} knowledge(s)`);
+    console.log(`  - ${reasoningCount} raciocinio(s)`);
+    console.log("  - Artefatos relacionados");
+    console.log("  - Reviews pendentes");
+    console.log("  - Snapshots de recovery");
+    console.log("  - Knowledge graph (relacoes)");
+    console.log("  - Session summaries");
+    console.log("  - Gate bypasses");
+
+    console.log("\n" + "─".repeat(60));
+    console.log("\nO seguinte sera MANTIDO:\n");
+    console.log("  - Configuracao do projeto (stack)");
+    console.log("  - Standards");
+    console.log("  - Contexto de produto (PRD)");
+    console.log("  - Goals e features do produto");
+    console.log("  - Contexto de bibliotecas");
+    console.log("  - Implementation patterns");
+    console.log("  - Arquivos gerados (standards.md, product-context.md, patterns.md)");
+
+    console.log("\n" + "─".repeat(60));
+    console.log("\nPara confirmar a limpeza, execute:");
+    console.log("  bun run .claude/cli/workflow.ts clear --force\n");
+
+    return;
+  }
+
+  console.log("\n" + "═".repeat(60));
+  console.log("LIMPANDO TASKS...");
+  console.log("═".repeat(60) + "\n");
+
+  // Ordem de deleção respeita foreign keys
+  // v8.0: Incluindo novas tabelas
+  const tablesToClear = [
+    "session_summaries",
+    "reasoning_log",
+    "knowledge_graph",
+    "knowledge",
+    "gate_bypasses",
+    "snapshots",
+    "review",
+    "artifacts",
+    "decisions",
+    "tasks",
+    "context",
+    "specs",
+  ];
+
+  for (const table of tablesToClear) {
+    try {
+      const result = db.run(`DELETE FROM ${table}`);
+      console.log(`  Limpo: ${table} (${result.changes} registros)`);
+    } catch (err: any) {
+      // Tabela pode não existir em bancos antigos
+      if (!err.message.includes("no such table")) {
+        console.error(`  Erro ao limpar ${table}: ${err.message}`);
+      }
+    }
+  }
+
+  console.log("\n" + "═".repeat(60));
+  console.log("TASKS LIMPAS COM SUCESSO");
+  console.log("═".repeat(60));
+
+  console.log("\nConfiguracoes do projeto mantidas.");
+  console.log("\nProximo passo:");
+  console.log("  /codexa:feature - Iniciar uma nova feature\n");
+}
+
+/**
+ * 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`,
+  ];
+
+  const markdownFiles = [
+    join(codexaDir, "standards.md"),
+    join(codexaDir, "product-context.md"),
+    join(codexaDir, "patterns.md"),
+  ];
+
+  console.log("\n" + "═".repeat(60));
+  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("\nArquivos gerados:");
+  for (const file of markdownFiles) {
+    const status = existsSync(file) ? "existe" : "nao existe";
+    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}`);
+    }
+  }
+
+  console.log("\n" + "─".repeat(60));
+  console.log("Para limpar tasks (mantendo configs): clear --force\n");
+}
+
+// Exportar aliases para compatibilidade
+export { clearTasks as clearWorkflow };
+export { clearTasks as clearTasksOnly };

package/commands/decide.ts

@@ -0,0 +1,249 @@
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+
+function getNextDecisionId(specId: string): string {
+  const db = getDb();
+  const last = db
+    .query("SELECT id FROM decisions WHERE spec_id = ? ORDER BY created_at DESC LIMIT 1")
+    .get(specId) as any;
+
+  if (!last) return "DEC-001";
+
+  const num = parseInt(last.id.replace("DEC-", "")) + 1;
+  return `DEC-${num.toString().padStart(3, "0")}`;
+}
+
+interface ConflictAnalysis {
+  hasConflict: boolean;
+  conflictingDecisions: Array<{
+    id: string;
+    title: string;
+    decision: string;
+    reason: string;
+  }>;
+}
+
+// Extrair keywords relevantes de um texto
+function extractKeywords(text: string): string[] {
+  const stopWords = new Set([
+    "a", "o", "e", "de", "da", "do", "para", "com", "em", "que", "usar",
+    "the", "and", "or", "to", "for", "with", "in", "on", "is", "are", "be",
+    "will", "should", "must", "can", "use", "using", "como", "ser", "sera"
+  ]);
+
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, " ")
+    .split(/\s+/)
+    .filter((word) => word.length > 2 && !stopWords.has(word));
+}
+
+// Detectar conflitos semanticos entre decisoes
+function detectConflicts(
+  newTitle: string,
+  newDecision: string,
+  existingDecisions: any[]
+): ConflictAnalysis {
+  const conflicts: ConflictAnalysis["conflictingDecisions"] = [];
+
+  const newKeywords = new Set([
+    ...extractKeywords(newTitle),
+    ...extractKeywords(newDecision),
+  ]);
+
+  // Padroes de conflito conhecidos
+  const conflictPatterns: Array<{ patterns: string[][]; reason: string }> = [
+    {
+      patterns: [["rest", "api"], ["graphql"]],
+      reason: "Conflito de paradigma de API (REST vs GraphQL)",
+    },
+    {
+      patterns: [["jwt", "token"], ["session", "cookie"]],
+      reason: "Conflito de estrategia de autenticacao",
+    },
+    {
+      patterns: [["zustand"], ["redux"]],
+      reason: "Conflito de biblioteca de estado",
+    },
+    {
+      patterns: [["prisma"], ["drizzle"]],
+      reason: "Conflito de ORM",
+    },
+    {
+      patterns: [["mysql"], ["postgres", "postgresql"]],
+      reason: "Conflito de banco de dados",
+    },
+    {
+      patterns: [["server", "component"], ["client", "component"]],
+      reason: "Conflito de tipo de componente padrao",
+    },
+    {
+      patterns: [["tailwind"], ["styled", "component"]],
+      reason: "Conflito de abordagem de styling",
+    },
+    {
+      patterns: [["vitest"], ["jest"]],
+      reason: "Conflito de framework de testes",
+    },
+  ];
+
+  for (const existing of existingDecisions) {
+    const existingKeywords = new Set([
+      ...extractKeywords(existing.title),
+      ...extractKeywords(existing.decision),
+    ]);
+
+    // Verificar padroes de conflito conhecidos
+    for (const { patterns, reason } of conflictPatterns) {
+      const [patternA, patternB] = patterns;
+
+      const newHasA = patternA.some((p) => newKeywords.has(p));
+      const newHasB = patternB.some((p) => newKeywords.has(p));
+      const existingHasA = patternA.some((p) => existingKeywords.has(p));
+      const existingHasB = patternB.some((p) => existingKeywords.has(p));
+
+      // Conflito: nova decisao menciona A, existente menciona B (ou vice-versa)
+      if ((newHasA && existingHasB) || (newHasB && existingHasA)) {
+        conflicts.push({
+          id: existing.id,
+          title: existing.title,
+          decision: existing.decision,
+          reason,
+        });
+        break; // Apenas um conflito por decisao existente
+      }
+    }
+
+    // Verificar sobreposicao alta de keywords (mesmo topico, decisoes diferentes?)
+    if (conflicts.every((c) => c.id !== existing.id)) {
+      const intersection = [...newKeywords].filter((k) => existingKeywords.has(k));
+      const similarity = intersection.length / Math.max(newKeywords.size, existingKeywords.size);
+
+      if (similarity > 0.4 && intersection.length >= 3) {
+        conflicts.push({
+          id: existing.id,
+          title: existing.title,
+          decision: existing.decision,
+          reason: `Alta sobreposicao de topico (${Math.round(similarity * 100)}% similar) - verificar se sao decisoes conflitantes`,
+        });
+      }
+    }
+  }
+
+  return {
+    hasConflict: conflicts.length > 0,
+    conflictingDecisions: conflicts,
+  };
+}
+
+export function decide(title: string, decision: string, options: { rationale?: string; force?: boolean }): void {
+  initSchema();
+
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  const spec = db
+    .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
+    .get() as any;
+
+  if (!spec) {
+    console.error("\nNenhuma feature ativa.\n");
+    process.exit(1);
+  }
+
+  // Verificar conflitos com decisoes existentes
+  const existingDecisions = db
+    .query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'")
+    .all(spec.id) as any[];
+
+  if (existingDecisions.length > 0 && !options.force) {
+    const analysis = detectConflicts(title, decision, existingDecisions);
+
+    if (analysis.hasConflict) {
+      console.warn("\n⚠ POTENCIAL CONFLITO DETECTADO:\n");
+      console.warn(`Nova decisao: "${title}"`);
+      console.warn(`  ${decision}\n`);
+
+      for (const conflict of analysis.conflictingDecisions) {
+        console.warn(`Pode conflitar com: ${conflict.id} - "${conflict.title}"`);
+        console.warn(`  ${conflict.decision}`);
+        console.warn(`  Motivo: ${conflict.reason}\n`);
+      }
+
+      console.warn(`${"─".repeat(50)}`);
+      console.warn(`Para registrar mesmo assim, use: decide "${title}" "${decision}" --force`);
+      console.warn(`Ou revise as decisoes existentes com: decisions\n`);
+      process.exit(1);
+    }
+  }
+
+  // Pegar task atual em execucao
+  const currentTask = db
+    .query("SELECT * FROM tasks WHERE spec_id = ? AND status = 'running' LIMIT 1")
+    .get(spec.id) as any;
+
+  const decisionId = getNextDecisionId(spec.id);
+
+  db.run(
+    `INSERT INTO decisions (id, spec_id, task_ref, title, decision, rationale, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, 'active', ?)`,
+    [
+      decisionId,
+      spec.id,
+      currentTask?.number || null,
+      title,
+      decision,
+      options.rationale || null,
+      now,
+    ]
+  );
+
+  console.log(`\nDecisao registrada: ${decisionId}`);
+  console.log(`Titulo: ${title}`);
+  console.log(`Decisao: ${decision}`);
+  if (options.rationale) console.log(`Racional: ${options.rationale}`);
+  if (currentTask) console.log(`Task: #${currentTask.number}`);
+  if (options.force) console.log(`[!] Registrada com --force (conflito ignorado)`);
+  console.log();
+}
+
+export function listDecisions(json: boolean = false): void {
+  initSchema();
+
+  const db = getDb();
+
+  const spec = db
+    .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
+    .get() as any;
+
+  if (!spec) {
+    console.error("\nNenhuma feature ativa.\n");
+    process.exit(1);
+  }
+
+  const decisions = db
+    .query("SELECT * FROM decisions WHERE spec_id = ? ORDER BY created_at")
+    .all(spec.id) as any[];
+
+  if (json) {
+    console.log(JSON.stringify({ decisions }));
+    return;
+  }
+
+  if (decisions.length === 0) {
+    console.log("\nNenhuma decisao registrada.\n");
+    return;
+  }
+
+  console.log(`\nDecisoes (${decisions.length}):`);
+  console.log(`${"─".repeat(60)}`);
+
+  for (const dec of decisions) {
+    const taskRef = dec.task_ref ? ` [Task #${dec.task_ref}]` : "";
+    const status = dec.status === "active" ? "" : ` (${dec.status})`;
+    console.log(`${dec.id}: ${dec.title}${taskRef}${status}`);
+    console.log(`  ${dec.decision}`);
+    if (dec.rationale) console.log(`  Racional: ${dec.rationale}`);
+    console.log();
+  }
+}