@codexa/cli 9.0.3 → 9.0.5

package/commands/architect.ts

@@ -1,6 +1,7 @@
 import { getDb } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { CodexaError } from "../errors";
 import { join } from "path";
 
 // ═══════════════════════════════════════════════════════════════
@@ -364,7 +365,7 @@ export function architectStart(description: string, options: { json?: boolean }
       console.log(`  Criada: ${pending.created_at}`);
       console.log("\nUse 'architect show' para ver detalhes ou 'architect cancel' para cancelar.\n");
     }
-    process.exit(1);
+    throw new CodexaError("Ja existe uma analise pendente. Use 'architect show' ou 'architect cancel'.");
   }
 
   // Criar nova analise
@@ -566,7 +567,7 @@ export function architectSave(options: { file?: string; json?: boolean }): void
     } else {
       console.log("\n[ERRO] Nenhuma analise pendente encontrada.\n");
     }
-    process.exit(1);
+    throw new CodexaError("Nenhuma analise pendente encontrada.");
   }
 
   // v8.4: Resolver caminho do arquivo .md
@@ -587,7 +588,7 @@ export function architectSave(options: { file?: string; json?: boolean }): void
       console.log(`\n[ERRO] Arquivo nao encontrado: ${filePath}`);
       console.log("O agente architect deve escrever o .md antes de chamar 'architect save'.\n");
     }
-    process.exit(1);
+    throw new CodexaError(`Arquivo nao encontrado: ${filePath}`);
   }
 
   const content = readFileSync(filePath, "utf-8");
@@ -697,7 +698,7 @@ export function architectApprove(options: { id?: string; json?: boolean }): void
     } else {
       console.log("\n[ERRO] Analise nao encontrada.\n");
     }
-    process.exit(1);
+    throw new CodexaError("Analise nao encontrada.");
   }
 
   if (analysis.status !== "pending") {
@@ -706,7 +707,7 @@ export function architectApprove(options: { id?: string; json?: boolean }): void
     } else {
       console.log(`\n[ERRO] Analise ja esta com status '${analysis.status}'.\n`);
     }
-    process.exit(1);
+    throw new CodexaError(`Analise ja esta com status '${analysis.status}'.`);
   }
 
   db.run(
@@ -750,7 +751,7 @@ export function architectExport(options: { id?: string; json?: boolean }): void
       console.log("\n[ERRO] Nenhuma analise aprovada encontrada.");
       console.log("Use 'architect approve' primeiro.\n");
     }
-    process.exit(1);
+    throw new CodexaError("Nenhuma analise aprovada encontrada. Use 'architect approve' primeiro.");
   }
 
   const babySteps: BabyStep[] = analysis.baby_steps ? JSON.parse(analysis.baby_steps) : [];

package/commands/check.ts

@@ -1,15 +1,14 @@
 import { getDb } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { enforceGate } from "../gates/validator";
+import { resolveSpec } from "./spec-resolver";
 
-export function checkRequest(): void {
+export function checkRequest(specId?: string): 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 spec = resolveSpec(specId, ["planning"]);
 
   const tasks = db
     .query("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number")
@@ -68,16 +67,14 @@ export function checkRequest(): void {
   console.log(`Para ajustar: plan task-add (adiciona mais tasks)\n`);
 }
 
-export function checkApprove(): void {
+export function checkApprove(specId?: string): 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;
+  const spec = resolveSpec(specId, ["checking"]);
 
   // Atualizar para aprovado
   db.run(
@@ -100,20 +97,13 @@ export function checkApprove(): void {
   console.log(`3. Complete uma task com: task done <id> --checkpoint "..."\n`);
 }
 
-export function checkReject(reason: string): void {
+export function checkReject(reason: string, specId?: 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);
-  }
+  const spec = resolveSpec(specId, ["checking"]);
 
   // Voltar para planning
   db.run("UPDATE specs SET phase = 'planning', updated_at = ? WHERE id = ?", [now, spec.id]);

package/commands/clear.ts

@@ -5,6 +5,7 @@ import { join, dirname } from "path";
 
 interface ClearOptions {
   force?: boolean;
+  specId?: string;
 }
 
 /**
@@ -64,6 +65,45 @@ export function clearTasks(options: ClearOptions = {}): void {
     return;
   }
 
+  // Per-spec clear or clear all
+  if (options.specId) {
+    console.log("\n" + "═".repeat(60));
+    console.log(`LIMPANDO SPEC: ${options.specId}`);
+    console.log("═".repeat(60) + "\n");
+
+    const tablesWithSpecId = [
+      "reasoning_log",
+      "knowledge_graph",
+      "knowledge",
+      "gate_bypasses",
+      "snapshots",
+      "review",
+      "artifacts",
+      "decisions",
+      "tasks",
+      "context",
+      "specs",
+    ];
+
+    for (const table of tablesWithSpecId) {
+      try {
+        const result = db.run(`DELETE FROM ${table} WHERE spec_id = ?`, [options.specId]);
+        if (result.changes > 0) {
+          console.log(`  Limpo: ${table} (${result.changes} registros)`);
+        }
+      } catch (err: any) {
+        if (!err.message.includes("no such table") && !err.message.includes("no such column")) {
+          console.error(`  Erro ao limpar ${table}: ${err.message}`);
+        }
+      }
+    }
+
+    console.log("\n" + "═".repeat(60));
+    console.log(`SPEC ${options.specId} LIMPO`);
+    console.log("═".repeat(60) + "\n");
+    return;
+  }
+
   console.log("\n" + "═".repeat(60));
   console.log("LIMPANDO TASKS...");
   console.log("═".repeat(60) + "\n");

package/commands/decide.ts

@@ -1,5 +1,7 @@
 import { getDb } from "../db/connection";
 import { initSchema, getNextDecisionId } from "../db/schema";
+import { resolveSpec } from "./spec-resolver";
+import { CodexaError } from "../errors";
 
 interface ConflictAnalysis {
   hasConflict: boolean;
@@ -124,20 +126,13 @@ function detectConflicts(
   };
 }
 
-export function decide(title: string, decision: string, options: { rationale?: string; force?: boolean }): void {
+export function decide(title: string, decision: string, options: { rationale?: string; force?: boolean; specId?: string }): 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);
-  }
+  const spec = resolveSpec(options.specId);
 
   // Verificar conflitos com decisoes existentes
   const existingDecisions = db
@@ -159,9 +154,9 @@ export function decide(title: string, decision: string, options: { rationale?: s
       }
 
       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);
+      throw new CodexaError(
+        `Potencial conflito detectado.\nPara registrar mesmo assim, use: decide "${title}" "${decision}" --force\nOu revise as decisoes existentes com: decisions`
+      );
     }
   }
 
@@ -207,19 +202,12 @@ export function decide(title: string, decision: string, options: { rationale?: s
   console.log();
 }
 
-export function listDecisions(json: boolean = false): void {
+export function listDecisions(json: boolean = false, specId?: string): 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 spec = resolveSpec(specId);
 
   const decisions = db
     .query("SELECT * FROM decisions WHERE spec_id = ? ORDER BY created_at")

package/commands/discover.ts

@@ -11,6 +11,7 @@ import {
   getDetailedTechnologies,
   type UnifiedDetectionResult,
 } from "../detectors/loader";
+import { CodexaError } from "../errors";
 
 interface StackDetection {
   frontend?: string;
@@ -172,9 +173,7 @@ export function discoverConfirm(): void {
 
   const pending = db.query("SELECT * FROM project WHERE id = 'pending'").get() as any;
   if (!pending) {
-    console.error("\nNenhuma descoberta pendente.");
-    console.error("Execute: discover start primeiro\n");
-    process.exit(1);
+    throw new CodexaError("Nenhuma descoberta pendente.\nExecute: discover start primeiro");
   }
 
   const data = JSON.parse(pending.stack);
@@ -283,9 +282,7 @@ export function discoverShow(json: boolean = false): void {
   const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
 
   if (!project) {
-    console.error("\nProjeto nao descoberto.");
-    console.error("Execute: discover start\n");
-    process.exit(1);
+    throw new CodexaError("Projeto nao descoberto.\nExecute: discover start");
   }
 
   const standards = db.query("SELECT * FROM standards ORDER BY category, scope").all() as any[];
@@ -381,9 +378,7 @@ export async function discoverRefresh(options: { force?: boolean } = {}): Promis
 
   const currentProject = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
   if (!currentProject) {
-    console.error("\nProjeto nao descoberto.");
-    console.error("Execute: discover start primeiro\n");
-    process.exit(1);
+    throw new CodexaError("Projeto nao descoberto.\nExecute: discover start primeiro");
   }
 
   const currentStack = JSON.parse(currentProject.stack);
@@ -466,9 +461,7 @@ export async function discoverIncremental(): Promise<void> {
 
   const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
   if (!project) {
-    console.error("\nProjeto nao descoberto.");
-    console.error("Execute: discover start primeiro\n");
-    process.exit(1);
+    throw new CodexaError("Projeto nao descoberto.\nExecute: discover start primeiro");
   }
 
   // Data de referencia: last_discover_at > discovered_at > fallback 30 dias
@@ -774,9 +767,7 @@ export function discoverPatternsShow(name: string, json: boolean = false): void
   const pattern = db.query("SELECT * FROM implementation_patterns WHERE name = ?").get(name) as any;
 
   if (!pattern) {
-    console.error(`\nPattern '${name}' nao encontrado.`);
-    console.error("Use: discover patterns para listar todos\n");
-    process.exit(1);
+    throw new CodexaError(`Pattern '${name}' nao encontrado.\nUse: discover patterns para listar todos`);
   }
 
   const structure = JSON.parse(pattern.structure || "{}");
@@ -876,9 +867,7 @@ export function discoverPatternAdd(options: {
   // Verificar se pattern ja existe
   const existing = db.query("SELECT id FROM implementation_patterns WHERE name = ?").get(options.name);
   if (existing) {
-    console.error(`\nPattern '${options.name}' ja existe.`);
-    console.error("Use: discover pattern-edit para modificar\n");
-    process.exit(1);
+    throw new CodexaError(`Pattern '${options.name}' ja existe.\nUse: discover pattern-edit para modificar`);
   }
 
   const now = new Date().toISOString();
@@ -925,9 +914,7 @@ export function discoverPatternEdit(name: string, options: {
 
   const existing = db.query("SELECT * FROM implementation_patterns WHERE name = ?").get(name) as any;
   if (!existing) {
-    console.error(`\nPattern '${name}' nao encontrado.`);
-    console.error("Use: discover patterns para listar todos\n");
-    process.exit(1);
+    throw new CodexaError(`Pattern '${name}' nao encontrado.\nUse: discover patterns para listar todos`);
   }
 
   const updates: string[] = [];
@@ -967,8 +954,7 @@ export function discoverPatternEdit(name: string, options: {
   }
 
   if (updates.length === 0) {
-    console.error("\nNenhuma opcao de atualizacao fornecida.\n");
-    process.exit(1);
+    throw new CodexaError("Nenhuma opcao de atualizacao fornecida.");
   }
 
   updates.push("updated_at = ?");
@@ -993,8 +979,7 @@ export function discoverPatternRemove(name: string): void {
 
   const existing = db.query("SELECT id FROM implementation_patterns WHERE name = ?").get(name);
   if (!existing) {
-    console.error(`\nPattern '${name}' nao encontrado.\n`);
-    process.exit(1);
+    throw new CodexaError(`Pattern '${name}' nao encontrado.`);
   }
 
   db.run("DELETE FROM implementation_patterns WHERE name = ?", [name]);
@@ -1013,9 +998,7 @@ export function discoverRefreshPatterns(): void {
   // Verificar se projeto foi descoberto
   const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
   if (!project) {
-    console.error("\nProjeto nao descoberto.");
-    console.error("Execute: discover start primeiro\n");
-    process.exit(1);
+    throw new CodexaError("Projeto nao descoberto.\nExecute: discover start primeiro");
   }
 
   console.log("\n⚠ Refresh de patterns requer analise manual do codigo.");

package/commands/knowledge.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { jaccardSimilarity, compactKnowledge } from "./knowledge";
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+
+describe("jaccardSimilarity", () => {
+  it("returns 1 for identical strings", () => {
+    expect(jaccardSimilarity("hello world test", "hello world test")).toBe(1);
+  });
+
+  it("returns 0 for completely different strings", () => {
+    expect(jaccardSimilarity("apple banana cherry", "delta echo foxtrot")).toBe(0);
+  });
+
+  it("returns high similarity for near-duplicates", () => {
+    const sim = jaccardSimilarity(
+      "Implemented user authentication with JWT tokens",
+      "Implemented user authentication using JWT tokens"
+    );
+    expect(sim).toBeGreaterThan(0.7);
+  });
+
+  it("returns 1 for two empty strings", () => {
+    expect(jaccardSimilarity("", "")).toBe(1);
+  });
+
+  it("returns 0 when one string is empty", () => {
+    expect(jaccardSimilarity("hello world test", "")).toBe(0);
+  });
+
+  it("is case insensitive", () => {
+    expect(jaccardSimilarity("Hello World Test", "hello world test")).toBe(1);
+  });
+
+  it("ignores short words (<=2 chars)", () => {
+    // "a" and "is" are filtered out, only "cat" and "dog" matter
+    const sim = jaccardSimilarity("a cat is here", "a dog is here");
+    // "cat" vs "dog" + "here" in common
+    expect(sim).toBeGreaterThan(0);
+    expect(sim).toBeLessThan(1);
+  });
+
+  it("strips punctuation", () => {
+    const sim = jaccardSimilarity("hello, world! test.", "hello world test");
+    expect(sim).toBe(1);
+  });
+});
+
+describe("compactKnowledge", () => {
+  beforeEach(() => {
+    initSchema();
+    const db = getDb();
+    db.run("DELETE FROM knowledge_graph");
+    db.run("DELETE FROM knowledge");
+    db.run("DELETE FROM tasks");
+    db.run("DELETE FROM context");
+    db.run("DELETE FROM specs");
+  });
+
+  function createSpec(id: string, phase: string) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    db.run(
+      "INSERT INTO specs (id, name, phase, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+      [id, `Feature ${id}`, phase, now, now]
+    );
+  }
+
+  function addKnowledgeEntry(specId: string, content: string, category: string, severity: string, createdAt?: string) {
+    const db = getDb();
+    const now = createdAt || new Date().toISOString();
+    db.run(
+      `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
+       VALUES (?, 0, ?, ?, ?, 'all', ?)`,
+      [specId, category, content, severity, now]
+    );
+  }
+
+  it("merges similar entries in same category and spec", () => {
+    createSpec("spec-a", "implementing");
+    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the login flow", "discovery", "info");
+    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for login flow", "discovery", "info");
+
+    // Dry run first
+    compactKnowledge({ dryRun: true, json: true });
+
+    // Actual compact
+    compactKnowledge({ json: true });
+
+    const db = getDb();
+    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    expect(archived.c).toBe(1);
+  });
+
+  it("keeps higher severity entry when merging", () => {
+    createSpec("spec-a", "implementing");
+    addKnowledgeEntry("spec-a", "Database connection timeout causing failures in production", "blocker", "critical");
+    addKnowledgeEntry("spec-a", "Database connection timeout causing failures in production system", "blocker", "info");
+
+    compactKnowledge({ json: true });
+
+    const db = getDb();
+    const remaining = db.query("SELECT * FROM knowledge WHERE severity != 'archived'").all() as any[];
+    expect(remaining.length).toBe(1);
+    expect(remaining[0].severity).toBe("critical");
+  });
+
+  it("archives old info entries (>7 days)", () => {
+    createSpec("spec-a", "implementing");
+    const oldDate = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString();
+    addKnowledgeEntry("spec-a", "Some old discovery that is not referenced anywhere in the graph", "discovery", "info", oldDate);
+    addKnowledgeEntry("spec-a", "A recent discovery that should not be archived by this compaction", "discovery", "info");
+
+    compactKnowledge({ json: true });
+
+    const db = getDb();
+    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    expect(archived.c).toBe(1);
+  });
+
+  it("archives entries from completed specs", () => {
+    createSpec("spec-done", "completed");
+    addKnowledgeEntry("spec-done", "Something learned during completed feature implementation", "discovery", "info");
+    addKnowledgeEntry("spec-done", "A critical blocker that was found during the implementation phase", "blocker", "critical");
+
+    compactKnowledge({ json: true });
+
+    const db = getDb();
+    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    expect(archived.c).toBe(2);
+  });
+
+  it("dry-run mode does not modify DB", () => {
+    createSpec("spec-done", "completed");
+    addKnowledgeEntry("spec-done", "Something that would be archived in a real compaction run", "discovery", "info");
+
+    compactKnowledge({ dryRun: true, json: true });
+
+    const db = getDb();
+    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    expect(archived.c).toBe(0);
+  });
+
+  it("respects --spec filter", () => {
+    createSpec("spec-a", "implementing");
+    createSpec("spec-b", "implementing");
+    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the system", "discovery", "info");
+    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the system flow", "discovery", "info");
+    addKnowledgeEntry("spec-b", "Implemented user authentication with JWT tokens for the login", "discovery", "info");
+    addKnowledgeEntry("spec-b", "Implemented user authentication with JWT tokens for the login flow", "discovery", "info");
+
+    compactKnowledge({ specId: "spec-a", json: true });
+
+    const db = getDb();
+    const archivedA = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived' AND spec_id = 'spec-a'").get() as any;
+    const archivedB = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived' AND spec_id = 'spec-b'").get() as any;
+    expect(archivedA.c).toBe(1);
+    expect(archivedB.c).toBe(0);
+  });
+});