@codexa/cli 9.0.2 → 9.0.4

package/commands/spec-resolver.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { resolveSpec, getAllActiveSpecs } from "./spec-resolver";
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+
+beforeEach(() => {
+  initSchema();
+  const db = getDb();
+  // Limpar em ordem que respeita foreign keys
+  db.run("DELETE FROM reasoning_log");
+  db.run("DELETE FROM knowledge_graph");
+  db.run("DELETE FROM knowledge");
+  db.run("DELETE FROM gate_bypasses");
+  db.run("DELETE FROM snapshots");
+  db.run("DELETE FROM review");
+  db.run("DELETE FROM artifacts");
+  db.run("DELETE FROM decisions");
+  db.run("DELETE FROM tasks");
+  db.run("DELETE FROM context");
+  db.run("DELETE FROM specs");
+});
+
+function createSpec(id: string, name: string, phase: string, createdAt?: string) {
+  const db = getDb();
+  const now = createdAt || new Date().toISOString();
+  db.run(
+    "INSERT INTO specs (id, name, phase, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+    [id, name, phase, now, now]
+  );
+}
+
+describe("resolveSpec", () => {
+  it("returns spec by ID when specId provided", () => {
+    createSpec("spec-a", "Feature A", "planning");
+    createSpec("spec-b", "Feature B", "implementing");
+
+    const result = resolveSpec("spec-a");
+    expect(result.id).toBe("spec-a");
+    expect(result.name).toBe("Feature A");
+  });
+
+  it("returns most recent active spec when no specId", () => {
+    createSpec("spec-old", "Old Feature", "planning", "2026-01-01T00:00:00Z");
+    createSpec("spec-new", "New Feature", "implementing", "2026-02-01T00:00:00Z");
+
+    const result = resolveSpec();
+    expect(result.id).toBe("spec-new");
+  });
+
+  it("validates requiredPhases", () => {
+    createSpec("spec-a", "Feature A", "planning");
+
+    // Should work with matching phase
+    const result = resolveSpec("spec-a", ["planning"]);
+    expect(result.phase).toBe("planning");
+  });
+
+  it("accepts multiple requiredPhases", () => {
+    createSpec("spec-a", "Feature A", "checking");
+    const result = resolveSpec("spec-a", ["planning", "checking"]);
+    expect(result.phase).toBe("checking");
+  });
+
+  it("skips completed specs when no specId", () => {
+    createSpec("spec-done", "Done Feature", "completed", "2026-02-01T00:00:00Z");
+    createSpec("spec-active", "Active Feature", "planning", "2026-01-01T00:00:00Z");
+
+    const result = resolveSpec();
+    expect(result.id).toBe("spec-active");
+  });
+
+  it("skips cancelled specs when no specId", () => {
+    createSpec("spec-cancelled", "Cancelled Feature", "cancelled", "2026-02-01T00:00:00Z");
+    createSpec("spec-active", "Active Feature", "implementing", "2026-01-01T00:00:00Z");
+
+    const result = resolveSpec();
+    expect(result.id).toBe("spec-active");
+  });
+});
+
+describe("getAllActiveSpecs", () => {
+  it("returns empty array when no active specs", () => {
+    const result = getAllActiveSpecs();
+    expect(result).toEqual([]);
+  });
+
+  it("returns all active specs ordered by created_at DESC", () => {
+    createSpec("spec-old", "Old Feature", "planning", "2026-01-01T00:00:00Z");
+    createSpec("spec-new", "New Feature", "implementing", "2026-02-01T00:00:00Z");
+
+    const result = getAllActiveSpecs();
+    expect(result.length).toBe(2);
+    expect(result[0].id).toBe("spec-new");
+    expect(result[1].id).toBe("spec-old");
+  });
+
+  it("excludes completed and cancelled specs", () => {
+    createSpec("spec-active", "Active", "planning");
+    createSpec("spec-done", "Done", "completed");
+    createSpec("spec-cancelled", "Cancelled", "cancelled");
+
+    const result = getAllActiveSpecs();
+    expect(result.length).toBe(1);
+    expect(result[0].id).toBe("spec-active");
+  });
+
+  it("returns multiple specs in different phases", () => {
+    createSpec("spec-plan", "Planning Feature", "planning", "2026-01-01T00:00:00Z");
+    createSpec("spec-impl", "Implementing Feature", "implementing", "2026-01-02T00:00:00Z");
+    createSpec("spec-rev", "Reviewing Feature", "reviewing", "2026-01-03T00:00:00Z");
+
+    const result = getAllActiveSpecs();
+    expect(result.length).toBe(3);
+    // Ordered by created_at DESC
+    expect(result[0].id).toBe("spec-rev");
+    expect(result[1].id).toBe("spec-impl");
+    expect(result[2].id).toBe("spec-plan");
+  });
+});

package/commands/spec-resolver.ts

@@ -0,0 +1,90 @@
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+import { CodexaError } from "../errors";
+
+export interface ResolvedSpec {
+  id: string;
+  name: string;
+  phase: string;
+  approved_at: string | null;
+  analysis_id: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+/**
+ * Resolve qual spec usar para um comando.
+ * - Se specId fornecido: busca esse spec (erro se nao encontrado ou finalizado)
+ * - Se nao fornecido: busca o mais recente ativo (ORDER BY created_at DESC LIMIT 1)
+ * - Se requiredPhases: valida que spec.phase esta na lista
+ */
+export function resolveSpec(specId?: string, requiredPhases?: string[]): ResolvedSpec {
+  const db = getDb();
+
+  let spec: any;
+
+  if (specId) {
+    spec = db
+      .query("SELECT * FROM specs WHERE id = ?")
+      .get(specId);
+
+    if (!spec) {
+      throw new CodexaError(`Spec '${specId}' nao encontrado.`);
+    }
+
+    if (spec.phase === "completed" || spec.phase === "cancelled") {
+      throw new CodexaError(`Spec '${specId}' ja esta ${spec.phase}.`);
+    }
+  } else {
+    spec = db
+      .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
+      .get();
+
+    if (!spec) {
+      throw new CodexaError("Nenhuma feature ativa.");
+    }
+  }
+
+  if (requiredPhases && !requiredPhases.includes(spec.phase)) {
+    throw new CodexaError(
+      `Spec '${spec.name}' esta na fase '${spec.phase}', esperado: ${requiredPhases.join(" ou ")}.\nSpec ID: ${spec.id}`
+    );
+  }
+
+  return spec as ResolvedSpec;
+}
+
+/**
+ * Versao silenciosa de resolveSpec que retorna null em vez de process.exit(1).
+ * Util para comandos que tem tratamento especial (ex: json output, throw customizado).
+ */
+export function resolveSpecOrNull(specId?: string, requiredPhases?: string[]): ResolvedSpec | null {
+  const db = getDb();
+
+  let spec: any;
+
+  if (specId) {
+    spec = db.query("SELECT * FROM specs WHERE id = ?").get(specId);
+    if (!spec) return null;
+    if (spec.phase === "completed" || spec.phase === "cancelled") return null;
+  } else {
+    spec = db
+      .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
+      .get();
+    if (!spec) return null;
+  }
+
+  if (requiredPhases && !requiredPhases.includes(spec.phase)) return null;
+
+  return spec as ResolvedSpec;
+}
+
+/**
+ * Retorna todos os specs ativos (nao completed/cancelled).
+ */
+export function getAllActiveSpecs(): ResolvedSpec[] {
+  const db = getDb();
+  return db
+    .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC")
+    .all() as ResolvedSpec[];
+}

package/commands/standards.ts

@@ -1,6 +1,7 @@
 import { getDb } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { generateStandardsMarkdown } from "./discover";
+import { CodexaError, ValidationError } from "../errors";
 
 export function standardsList(options: { category?: string; scope?: string; json?: boolean }): void {
   initSchema();
@@ -69,22 +70,16 @@ export function standardsAdd(options: {
   const validEnforcement = ["required", "recommended"];
 
   if (!validCategories.includes(options.category)) {
-    console.error(`\nCategoria invalida: ${options.category}`);
-    console.error(`Validas: ${validCategories.join(", ")}\n`);
-    process.exit(2);
+    throw new ValidationError(`Categoria invalida: ${options.category}\nValidas: ${validCategories.join(", ")}`);
   }
 
   if (!validScopes.includes(options.scope)) {
-    console.error(`\nEscopo invalido: ${options.scope}`);
-    console.error(`Validos: ${validScopes.join(", ")}\n`);
-    process.exit(2);
+    throw new ValidationError(`Escopo invalido: ${options.scope}\nValidos: ${validScopes.join(", ")}`);
   }
 
   const enforcement = options.enforcement || "required";
   if (!validEnforcement.includes(enforcement)) {
-    console.error(`\nEnforcement invalido: ${enforcement}`);
-    console.error(`Validos: ${validEnforcement.join(", ")}\n`);
-    process.exit(2);
+    throw new ValidationError(`Enforcement invalido: ${enforcement}\nValidos: ${validEnforcement.join(", ")}`);
   }
 
   let examples = null;
@@ -131,8 +126,7 @@ export function standardsEdit(
   const existing = db.query("SELECT * FROM standards WHERE id = ?").get(standardId) as any;
 
   if (!existing) {
-    console.error(`\nStandard #${id} nao encontrado.\n`);
-    process.exit(1);
+    throw new CodexaError(`Standard #${id} nao encontrado.`);
   }
 
   const updates: string[] = [];
@@ -159,8 +153,7 @@ export function standardsEdit(
   }
 
   if (updates.length === 0) {
-    console.error("\nNenhuma alteracao fornecida.\n");
-    process.exit(2);
+    throw new ValidationError("Nenhuma alteracao fornecida.");
   }
 
   params.push(standardId);
@@ -181,8 +174,7 @@ export function standardsRemove(id: string): void {
   const existing = db.query("SELECT * FROM standards WHERE id = ?").get(standardId) as any;
 
   if (!existing) {
-    console.error(`\nStandard #${id} nao encontrado.\n`);
-    process.exit(1);
+    throw new CodexaError(`Standard #${id} nao encontrado.`);
   }
 
   db.run("DELETE FROM standards WHERE id = ?", [standardId]);

package/commands/sync.ts

@@ -0,0 +1,89 @@
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, copyFileSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { CodexaError } from "../errors";
+
+// Agents que sao referencias (nao spawnables como subagent_type)
+const REFERENCE_FILES = new Set([
+  "common-directives.md",
+  "subagent-return-protocol.md",
+]);
+
+function findPluginAgentsDir(): string | null {
+  // 1. Dev repo: git root + plugins/codexa-workflow/agents/
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+    const pluginDir = join(gitRoot, "plugins", "codexa-workflow", "agents");
+    if (existsSync(pluginDir)) return pluginDir;
+  } catch {
+    // Not in git repo
+  }
+
+  // 2. Global install: resolve from @codexa/cli package location
+  try {
+    const cliPath = execSync("bun pm ls -g 2>/dev/null || npm list -g @codexa/cli --parseable 2>/dev/null", {
+      encoding: "utf-8",
+    }).trim();
+    if (cliPath) {
+      // Navigate from cli package to sibling plugin
+      const lines = cliPath.split("\n").filter(l => l.includes("codexa"));
+      for (const line of lines) {
+        const trimmed = line.trim();
+        // Try parent paths to find the monorepo root
+        const parts = trimmed.split(/[/\\]/);
+        for (let i = parts.length - 1; i >= 0; i--) {
+          const candidate = join(parts.slice(0, i + 1).join("/"), "plugins", "codexa-workflow", "agents");
+          if (existsSync(candidate)) return candidate;
+        }
+      }
+    }
+  } catch {
+    // Package manager not available
+  }
+
+  return null;
+}
+
+export function syncAgents(options: { force?: boolean } = {}): void {
+  const pluginDir = findPluginAgentsDir();
+
+  if (!pluginDir) {
+    throw new CodexaError("Diretorio de agents do plugin nao encontrado.\nVerifique se voce esta no repositorio codexa ou se @codexa/cli esta instalado globalmente.");
+  }
+
+  const targetDir = join(process.cwd(), ".claude", "agents");
+  mkdirSync(targetDir, { recursive: true });
+
+  const agentFiles = readdirSync(pluginDir).filter(
+    (f) => f.endsWith(".md") && !REFERENCE_FILES.has(f)
+  );
+
+  let copied = 0;
+  let skipped = 0;
+
+  for (const file of agentFiles) {
+    const src = join(pluginDir, file);
+    const dst = join(targetDir, file);
+
+    if (existsSync(dst) && !options.force) {
+      skipped++;
+      continue;
+    }
+
+    copyFileSync(src, dst);
+    copied++;
+  }
+
+  console.log(`\n[OK] Agents sincronizados para .claude/agents/`);
+  console.log(`  Copiados: ${copied}`);
+  if (skipped > 0) {
+    console.log(`  Ignorados (ja existem): ${skipped} — use --force para sobrescrever`);
+  }
+  console.log(`  Total disponivel: ${agentFiles.length}`);
+  console.log(`\nAgents disponiveis como subagent_type:`);
+  for (const file of agentFiles) {
+    const name = file.replace(".md", "");
+    console.log(`  - ${name}`);
+  }
+  console.log();
+}