@codexa/cli 9.0.13 → 9.0.15

package/commands/plan.ts

@@ -2,7 +2,7 @@ import { getDb } from "../db/connection";
 import { initSchema, getArchitecturalAnalysisForSpec } from "../db/schema";
 import { resolveSpec } from "./spec-resolver";
 import { CodexaError, ValidationError } from "../errors";
-import { resolveAgent, resolveAgentName, suggestAgent, getCanonicalAgentNames } from "../context/agent-registry";
+import { resolveAgent, resolveAgentName, suggestAgent, getCanonicalAgentNames, getAgentsByDomain } from "../context/agent-registry";
 
 export function generateSpecId(name: string): string {
     const date = new Date().toISOString().split("T")[0];
@@ -273,6 +273,14 @@ export function planTaskAdd(options: {
     if (normalizedAgent) {
         const entry = resolveAgent(normalizedAgent);
         if (!entry) {
+            // Check if it's an ambiguous domain name (multiple agents)
+            const domainAgents = getAgentsByDomain(normalizedAgent.toLowerCase());
+            if (domainAgents.length > 1) {
+                const agentList = domainAgents.map(a => `"${a.canonical}"`).join(", ");
+                throw new ValidationError(
+                    `"${normalizedAgent}" e um dominio com ${domainAgents.length} agentes: ${agentList}.\nEspecifique qual agente usar.`
+                );
+            }
             const suggestion = suggestAgent(normalizedAgent);
             const hint = suggestion
                 ? `\nVoce quis dizer: "${suggestion}"?`

package/context/agent-registry.test.ts

@@ -7,6 +7,7 @@ import {
   buildAgentDomainMap,
   getAllAgentNames,
   getCanonicalAgentNames,
+  getAgentsByDomain,
 } from "./agent-registry";
 
 // ── AGENT_REGISTRY structure ─────────────────────────────────
@@ -90,6 +91,27 @@ describe("resolveAgent", () => {
   it("returns null for empty/null-like input", () => {
     expect(resolveAgent("")).toBeNull();
   });
+
+  // Domain-based resolution (v9.5)
+  it("resolves unambiguous domain names (1 agent in domain)", () => {
+    expect(resolveAgent("database")?.canonical).toBe("expert-postgres-developer");
+    expect(resolveAgent("testing")?.canonical).toBe("testing-unit");
+    expect(resolveAgent("review")?.canonical).toBe("expert-code-reviewer");
+    expect(resolveAgent("security")?.canonical).toBe("security-specialist");
+    expect(resolveAgent("explore")?.canonical).toBe("deep-explore");
+    expect(resolveAgent("architecture")?.canonical).toBe("architect");
+  });
+
+  it("returns null for ambiguous domain names (multiple agents)", () => {
+    // frontend has nextjs + flutter, backend has go + csharp + js
+    expect(resolveAgent("frontend")).toBeNull();
+    expect(resolveAgent("backend")).toBeNull();
+  });
+
+  it("domain resolution is case-insensitive", () => {
+    expect(resolveAgent("DATABASE")?.canonical).toBe("expert-postgres-developer");
+    expect(resolveAgent("Testing")?.canonical).toBe("testing-unit");
+  });
 });
 
 // ── resolveAgentName ─────────────────────────────────────────
@@ -111,6 +133,16 @@ describe("resolveAgentName", () => {
     expect(resolveAgentName("custom-agent")).toBe("custom-agent");
     expect(resolveAgentName("my-special-agent")).toBe("my-special-agent");
   });
+
+  it("resolves unambiguous domain names to canonical", () => {
+    expect(resolveAgentName("database")).toBe("expert-postgres-developer");
+    expect(resolveAgentName("testing")).toBe("testing-unit");
+  });
+
+  it("returns ambiguous domain names unchanged (backward compat)", () => {
+    expect(resolveAgentName("frontend")).toBe("frontend");
+    expect(resolveAgentName("backend")).toBe("backend");
+  });
 });
 
 // ── suggestAgent ─────────────────────────────────────────────
@@ -163,6 +195,35 @@ describe("buildAgentDomainMap", () => {
   });
 });
 
+// ── getAgentsByDomain ────────────────────────────────────────
+
+describe("getAgentsByDomain", () => {
+  it("returns agents in multi-agent domains", () => {
+    const frontend = getAgentsByDomain("frontend");
+    expect(frontend).toHaveLength(2);
+    expect(frontend.map(a => a.canonical)).toContain("expert-nextjs-developer");
+    expect(frontend.map(a => a.canonical)).toContain("frontend-flutter");
+
+    const backend = getAgentsByDomain("backend");
+    expect(backend).toHaveLength(3);
+  });
+
+  it("returns agents in single-agent domains", () => {
+    const database = getAgentsByDomain("database");
+    expect(database).toHaveLength(1);
+    expect(database[0].canonical).toBe("expert-postgres-developer");
+
+    const testing = getAgentsByDomain("testing");
+    expect(testing).toHaveLength(1);
+    expect(testing[0].canonical).toBe("testing-unit");
+  });
+
+  it("returns empty array for unknown domains", () => {
+    expect(getAgentsByDomain("unknown")).toHaveLength(0);
+    expect(getAgentsByDomain("general")).toHaveLength(0);
+  });
+});
+
 // ── getAllAgentNames / getCanonicalAgentNames ─────────────────
 
 describe("getAllAgentNames", () => {

package/context/agent-registry.ts

@@ -115,12 +115,21 @@ for (const entry of AGENT_REGISTRY) {
 
 /**
  * Resolve any agent name variant (canonical, filename, alias) to registry entry.
- * Case-insensitive. Returns null if no match found.
+ * Case-insensitive. Falls back to domain-based resolution when exactly 1 agent
+ * exists in the matching domain (e.g., "database" → expert-postgres-developer).
+ * Returns null if no match found or if domain has multiple agents (ambiguous).
  */
 export function resolveAgent(name: string): AgentEntry | null {
   if (!name) return null;
   const lower = name.toLowerCase();
-  return byCanonical.get(lower) ?? byAlias.get(lower) ?? null;
+  const direct = byCanonical.get(lower) ?? byAlias.get(lower);
+  if (direct) return direct;
+
+  // Domain fallback: resolve "frontend", "backend", etc. when unambiguous
+  const domainAgents = getAgentsByDomain(lower);
+  if (domainAgents.length === 1) return domainAgents[0];
+
+  return null;
 }
 
 /**
@@ -171,6 +180,14 @@ export function suggestAgent(input: string): string | null {
   return null;
 }
 
+/**
+ * Get all agents belonging to a specific domain.
+ * Used for domain-based resolution (e.g., "frontend" → agents in frontend domain).
+ */
+export function getAgentsByDomain(domain: string): AgentEntry[] {
+  return AGENT_REGISTRY.filter(e => e.domain === domain);
+}
+
 /**
  * Derive AGENT_DOMAIN map from registry (backward compat with domains.ts).
  */

package/gates/typecheck-validator.ts

@@ -137,32 +137,38 @@ function detectCommand(candidates: string[]): string | null {
 }
 
 function findConfigFile(files: string[], pattern: string): string | null {
-  // Buscar no cwd primeiro
-  const cwdCandidate = resolve(process.cwd(), pattern.replace("*.", ""));
-  if (!pattern.includes("*") && existsSync(cwdCandidate)) return cwdCandidate;
-
-  // Buscar subindo diretorios a partir dos arquivos
   const existingFiles = files.filter(f => existsSync(f));
-  if (existingFiles.length === 0) return null;
-
-  let dir = dirname(resolve(existingFiles[0]));
   const root = resolve("/");
-
-  while (dir !== root) {
-    if (pattern.includes("*")) {
-      // Glob simples: *.csproj
-      try {
-        const entries = require("fs").readdirSync(dir) as string[];
-        const ext = pattern.replace("*", "");
-        const match = entries.find((e: string) => e.endsWith(ext));
-        if (match) return resolve(dir, match);
-      } catch { /* continue */ }
-    } else {
-      const candidate = resolve(dir, pattern);
-      if (existsSync(candidate)) return candidate;
+  const cwd = process.cwd();
+
+  // Monorepo-aware: buscar subindo a partir dos arquivos primeiro,
+  // parando no cwd (raiz do projeto). Isso encontra o tsconfig mais
+  // proximo (ex: apps/frontend/tsconfig.json) antes do tsconfig raiz.
+  if (existingFiles.length > 0) {
+    let dir = dirname(resolve(existingFiles[0]));
+
+    while (dir !== root) {
+      if (pattern.includes("*")) {
+        try {
+          const entries = require("fs").readdirSync(dir) as string[];
+          const ext = pattern.replace("*", "");
+          const match = entries.find((e: string) => e.endsWith(ext));
+          if (match) return resolve(dir, match);
+        } catch { /* continue */ }
+      } else {
+        const candidate = resolve(dir, pattern);
+        if (existsSync(candidate)) return candidate;
+      }
+      dir = dirname(dir);
     }
-    dir = dirname(dir);
   }
+
+  // Fallback: cwd (so chega aqui se nenhum config foi encontrado subindo)
+  if (!pattern.includes("*")) {
+    const cwdCandidate = resolve(cwd, pattern.replace("*.", ""));
+    if (existsSync(cwdCandidate)) return cwdCandidate;
+  }
+
   return null;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "9.0.13",
+  "version": "9.0.15",
   "description": "Orchestrated workflow system for Claude Code - manages feature development through parallel subagents with structured phases, gates, and quality enforcement.",
   "type": "module",
   "bin": {