@codexa/cli 9.0.9 → 9.0.11

package/commands/discover.ts

@@ -12,6 +12,7 @@ import {
   type UnifiedDetectionResult,
 } from "../detectors/loader";
 import { CodexaError } from "../errors";
+import { getGrepaiWorkspace } from "./patterns";
 
 interface StackDetection {
   frontend?: string;
@@ -1123,19 +1124,36 @@ export function ensureDeepExploreAgent(): void {
     console.warn("  Instale com: go install github.com/your-org/grepai@latest");
     console.warn("  Sem grepai, o deep-explore usara apenas Grep (menos eficaz).\n");
   } else {
-    // Check if grepai index exists for this project
+    // Check if grepai index exists for this project (local GOB or workspace)
     const grepaiDir = join(process.cwd(), ".grepai");
-    if (!existsSync(grepaiDir)) {
+    const workspace = getGrepaiWorkspace();
+    if (!existsSync(grepaiDir) && !workspace) {
       console.warn("\n⚠ grepai index nao encontrado neste projeto.");
-      console.warn("  Execute: grepai index");
+      console.warn("  Execute: grepai init && grepai watch");
+      console.warn("  Ou configure um workspace: codexa discover set-stack --grepai-workspace <nome>");
       console.warn("  Sem o index, grepai search nao retornara resultados.\n");
+    } else if (workspace) {
+      console.log(`✓ grepai workspace configurado: ${workspace}`);
     }
   }
 
   // Ensure grepai permissions in target project settings
   ensureGrepaiPermissions();
 
-  if (existsSync(agentPath)) return;
+  // Check if workspace config changed — regenerate if needed
+  const currentWorkspace = getGrepaiWorkspace();
+  const wsFlag = currentWorkspace ? ` --workspace ${currentWorkspace}` : "";
+
+  if (existsSync(agentPath)) {
+    const existing = readFileSync(agentPath, "utf-8");
+    const hasWorkspace = existing.includes("--workspace ");
+    if ((currentWorkspace && !hasWorkspace) || (!currentWorkspace && hasWorkspace)) {
+      console.log("⟳ Atualizando deep-explore.md com config de workspace...");
+      // Fall through to regenerate
+    } else {
+      return; // Already up to date
+    }
+  }
 
   const agentsDir = join(process.cwd(), ".claude", "agents");
   if (!existsSync(agentsDir)) {
@@ -1165,7 +1183,7 @@ You are a semantic code exploration agent. Your primary tool is \\\`grepai\\\`
 **IMPORTANT: Execute ONE grepai search per Bash call. Do NOT run multiple grepai commands in parallel — this causes "Sibling tool call errored". Run them SEQUENTIALLY, one at a time.**
 
 \\\`\\\`\\\`bash
-grepai search "your query here" --json --compact
+grepai search "your query here" --json --compact${wsFlag}
 \\\`\\\`\\\`
 
 - Queries MUST be in English
@@ -1176,28 +1194,28 @@ grepai search "your query here" --json --compact
 Examples (run each one SEPARATELY):
 
 \\\`\\\`\\\`bash
-grepai search "authentication flow" --json --compact
+grepai search "authentication flow" --json --compact${wsFlag}
 \\\`\\\`\\\`
 
 \\\`\\\`\\\`bash
-grepai search "error handling middleware" --json --compact
+grepai search "error handling middleware" --json --compact${wsFlag}
 \\\`\\\`\\\`
 
 \\\`\\\`\\\`bash
-grepai search "database connection management" --json --compact
+grepai search "database connection management" --json --compact${wsFlag}
 \\\`\\\`\\\`
 
 ### Step 2: Use grepai trace for relationships
 
 \\\`\\\`\\\`bash
 # Find all functions that call a symbol
-grepai trace callers "HandleRequest" --json
+grepai trace callers "HandleRequest" --json${wsFlag}
 
 # Find all functions called by a symbol
-grepai trace callees "ProcessOrder" --json
+grepai trace callees "ProcessOrder" --json${wsFlag}
 
 # Build complete call graph
-grepai trace graph "ValidateToken" --depth 3 --json
+grepai trace graph "ValidateToken" --depth 3 --json${wsFlag}
 \\\`\\\`\\\`
 
 ### Step 3: Read files identified by grepai
@@ -1210,6 +1228,15 @@ Use Grep ONLY if you need exact string match (variable name, import path). Never
 
 ---
 
+### Workspace (cross-project search)
+
+If \\\`--workspace\\\` flag is included in the commands above, this project uses a grepai workspace
+for cross-project semantic search. The flag was injected automatically by the Codexa CLI.
+
+- With workspace: searches across ALL projects in the workspace
+- Without workspace: searches only the local project index
+- To filter by project: add \\\`--project <name>\\\`
+
 ### FORBIDDEN
 
 - **DO NOT** use \\\`find\\\` or \\\`ls\\\` to explore code — use \\\`grepai search\\\`

package/commands/patterns.ts

@@ -33,15 +33,42 @@ export function isGrepaiAvailable(): boolean {
   }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// WORKSPACE CONFIG
+// ═══════════════════════════════════════════════════════════════
+
+const WORKSPACE_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+
+export function isValidWorkspaceName(name: string): boolean {
+  return WORKSPACE_NAME_REGEX.test(name);
+}
+
+export function getGrepaiWorkspace(): string | null {
+  try {
+    initSchema();
+    const db = getDb();
+    const project = db.query(
+      "SELECT grepai_workspace FROM project WHERE id = 'default'"
+    ).get() as any;
+    return project?.grepai_workspace || null;
+  } catch {
+    return null;
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // BUSCA SEMÂNTICA
 // ═══════════════════════════════════════════════════════════════
 
-export function searchWithGrepai(query: string, topK: number = 10): GrepaiResult[] {
+export function searchWithGrepai(query: string, topK: number = 10, workspace?: string): GrepaiResult[] {
   try {
+    const args = ["search", query, "--top", topK.toString(), "--format", "json"];
+    if (workspace) {
+      args.push("--workspace", workspace);
+    }
     const result = spawnSync(
       "grepai",
-      ["search", query, "--top", topK.toString(), "--format", "json"],
+      args,
       { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
     );
 

package/commands/sync.ts

@@ -1,7 +1,8 @@
 import { execSync } from "child_process";
-import { existsSync, mkdirSync, copyFileSync, readdirSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, copyFileSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { CodexaError } from "../errors";
+import { getGrepaiWorkspace } from "./patterns";
 
 // Agents que sao referencias (nao spawnables como subagent_type)
 const REFERENCE_FILES = new Set([
@@ -71,6 +72,16 @@ export function syncAgents(options: { force?: boolean } = {}): void {
     }
 
     copyFileSync(src, dst);
+
+    // Inject workspace flag in deep-explore if configured
+    if (file === "deep-explore.md") {
+      const workspace = getGrepaiWorkspace();
+      const wsFlag = workspace ? ` --workspace ${workspace}` : "";
+      let agentContent = readFileSync(dst, "utf-8");
+      agentContent = agentContent.replace(/\{\{GREPAI_WS_FLAG\}\}/g, wsFlag);
+      writeFileSync(dst, agentContent);
+    }
+
     copied++;
   }
 

package/commands/team.test.ts

@@ -0,0 +1,253 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import {
+  detectPhase,
+  buildLeadSpawnInstruction,
+  buildImpSpawnPrompt,
+  buildRevSpawnPrompt,
+  buildArchitectSpawnPrompt,
+  buildDevilAdvocatePrompt,
+  type TeammateConfig,
+} from "./team";
+
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+function createTestDb(): Database {
+  const db = new Database(":memory:");
+
+  db.run(`CREATE TABLE specs (
+    id TEXT PRIMARY KEY, name TEXT, phase TEXT, approved_at TEXT,
+    analysis_id TEXT, created_at TEXT, updated_at TEXT
+  )`);
+
+  db.run(`CREATE TABLE tasks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT, spec_id TEXT, number INTEGER,
+    name TEXT, depends_on TEXT, can_parallel INTEGER DEFAULT 1,
+    agent TEXT, files TEXT, status TEXT DEFAULT 'pending',
+    checkpoint TEXT, started_at TEXT, completed_at TEXT
+  )`);
+
+  db.run(`CREATE TABLE artifacts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT, spec_id TEXT,
+    task_ref INTEGER, path TEXT, action TEXT, created_at TEXT
+  )`);
+
+  db.run(`CREATE TABLE architectural_analyses (
+    id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, status TEXT DEFAULT 'pending'
+  )`);
+
+  db.run(`CREATE TABLE project (
+    id TEXT PRIMARY KEY DEFAULT 'default', stack TEXT,
+    cli_version TEXT, typecheck_command TEXT, grepai_workspace TEXT
+  )`);
+
+  db.run("INSERT INTO project (id) VALUES ('default')");
+
+  return db;
+}
+
+function insertSpec(db: Database, id: string, name: string, phase: string): void {
+  db.run("INSERT INTO specs (id, name, phase, created_at) VALUES (?, ?, ?, datetime('now'))", [id, name, phase]);
+}
+
+function insertTask(
+  db: Database,
+  specId: string,
+  number: number,
+  name: string,
+  options: { agent?: string; canParallel?: boolean; dependsOn?: number[]; status?: string } = {}
+): number {
+  const result = db.run(
+    `INSERT INTO tasks (spec_id, number, name, agent, can_parallel, depends_on, status)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [
+      specId,
+      number,
+      name,
+      options.agent || "general",
+      options.canParallel !== false ? 1 : 0,
+      options.dependsOn ? JSON.stringify(options.dependsOn) : null,
+      options.status || "pending",
+    ]
+  );
+  return Number(result.lastInsertRowid);
+}
+
+function insertArtifact(db: Database, specId: string, taskRef: number, path: string): void {
+  db.run("INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, ?, ?, 'created')", [specId, taskRef, path]);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Tests
+// ─────────────────────────────────────────────────────────────────
+
+describe("detectPhase", () => {
+  it("detecta imp quando spec.phase = implementing", () => {
+    const db = createTestDb();
+    const spec = { phase: "implementing" };
+    expect(detectPhase(db, spec)).toBe("imp");
+  });
+
+  it("detecta rev quando spec.phase = reviewing", () => {
+    const db = createTestDb();
+    const spec = { phase: "reviewing" };
+    expect(detectPhase(db, spec)).toBe("rev");
+  });
+
+  it("detecta architect quando ha analise pendente", () => {
+    const db = createTestDb();
+    db.run("INSERT INTO architectural_analyses (name, status) VALUES ('test', 'pending')");
+    const spec = { phase: "planning" };
+    expect(detectPhase(db, spec)).toBe("architect");
+  });
+
+  it("retorna phase original se nao ha analise pendente", () => {
+    const db = createTestDb();
+    const spec = { phase: "planning" };
+    expect(detectPhase(db, spec)).toBe("planning");
+  });
+});
+
+describe("buildLeadSpawnInstruction", () => {
+  it("gera instrucao em linguagem natural", () => {
+    const teammates: TeammateConfig[] = [
+      { role: "backend-implementer", domain: "backend", taskIds: [1], spawnPrompt: "test prompt" },
+    ];
+    const instruction = buildLeadSpawnInstruction(teammates, "imp");
+    expect(instruction).toContain("Create an agent team");
+    expect(instruction).toContain("delegate mode");
+  });
+
+  it("inclui nome de todos teammates", () => {
+    const teammates: TeammateConfig[] = [
+      { role: "backend-implementer", domain: "backend", taskIds: [1], spawnPrompt: "p1" },
+      { role: "frontend-implementer", domain: "frontend", taskIds: [2], spawnPrompt: "p2" },
+    ];
+    const instruction = buildLeadSpawnInstruction(teammates, "imp");
+    expect(instruction).toContain("backend-implementer");
+    expect(instruction).toContain("frontend-implementer");
+  });
+
+  it("inclui instrucao de delegate mode", () => {
+    const teammates: TeammateConfig[] = [
+      { role: "test", domain: "test", taskIds: [], spawnPrompt: "p" },
+    ];
+    const instruction = buildLeadSpawnInstruction(teammates, "rev");
+    expect(instruction).toContain("do NOT implement anything yourself");
+  });
+
+  it("usa descricao correta por fase", () => {
+    const tm: TeammateConfig[] = [{ role: "r", domain: "d", taskIds: [], spawnPrompt: "p" }];
+    expect(buildLeadSpawnInstruction(tm, "imp")).toContain("implement parallel tasks");
+    expect(buildLeadSpawnInstruction(tm, "rev")).toContain("review artifacts");
+    expect(buildLeadSpawnInstruction(tm, "architect")).toContain("competing architectural");
+  });
+});
+
+describe("buildImpSpawnPrompt", () => {
+  it("inclui identidade de teammate", () => {
+    const prompt = buildImpSpawnPrompt({ name: "Test Feature" }, "backend", [
+      { number: 1, name: "Task 1", id: 10, files: '["src/a.ts"]' },
+    ]);
+    expect(prompt).toContain("TEAMMATE de implementacao");
+    expect(prompt).toContain("Dominio: backend");
+  });
+
+  it("inclui secao TASK LIST com instrucao de ignorar nativa", () => {
+    const prompt = buildImpSpawnPrompt({ name: "F" }, "backend", [
+      { number: 1, name: "T1", id: 1, files: null },
+    ]);
+    expect(prompt).toContain("TASK LIST");
+    expect(prompt).toContain("IGNORE");
+    expect(prompt).toContain("Codexa tasks");
+  });
+
+  it("inclui instrucao de messaging nativo", () => {
+    const prompt = buildImpSpawnPrompt({ name: "F" }, "backend", [
+      { number: 1, name: "T1", id: 1, files: null },
+    ]);
+    expect(prompt).toContain("ferramenta `message`");
+    expect(prompt).toContain("codexa knowledge add");
+  });
+
+  it("lista todas tasks atribuidas", () => {
+    const prompt = buildImpSpawnPrompt({ name: "F" }, "backend", [
+      { number: 1, name: "Create schema", id: 10, files: '["db/schema.ts"]' },
+      { number: 2, name: "Add migration", id: 11, files: null },
+    ]);
+    expect(prompt).toContain("Task #1: Create schema");
+    expect(prompt).toContain("Task #2: Add migration");
+  });
+});
+
+describe("buildRevSpawnPrompt", () => {
+  it("inclui lente correta", () => {
+    const prompt = buildRevSpawnPrompt({ name: "F" }, "security", ["src/a.ts"]);
+    expect(prompt).toContain("**SECURITY**");
+    expect(prompt).toContain("OWASP");
+  });
+
+  it("inclui instrucao de message para enviar findings", () => {
+    const prompt = buildRevSpawnPrompt({ name: "F" }, "performance", ["src/a.ts"]);
+    expect(prompt).toContain("ferramenta `message`");
+  });
+
+  it("inclui instrucao de ignorar task list nativa", () => {
+    const prompt = buildRevSpawnPrompt({ name: "F" }, "standards", ["src/a.ts"]);
+    expect(prompt).toContain("IGNORE a task list nativa");
+  });
+
+  it("lista artefatos para revisao", () => {
+    const prompt = buildRevSpawnPrompt({ name: "F" }, "security", ["src/a.ts", "src/b.ts"]);
+    expect(prompt).toContain("- src/a.ts");
+    expect(prompt).toContain("- src/b.ts");
+  });
+});
+
+describe("buildArchitectSpawnPrompt", () => {
+  it("inclui identidade de architect", () => {
+    const prompt = buildArchitectSpawnPrompt({ name: "Add auth" }, {}, "alpha");
+    expect(prompt).toContain("ARCHITECT ALPHA");
+  });
+
+  it("inclui instrucao de message para proposta", () => {
+    const prompt = buildArchitectSpawnPrompt({ name: "Add auth" }, {}, "beta");
+    expect(prompt).toContain("ferramenta `message`");
+    expect(prompt).toContain("Enviar ao Lead");
+  });
+
+  it("inclui 8 headers obrigatorios", () => {
+    const prompt = buildArchitectSpawnPrompt({ name: "Add auth" }, {}, "alpha");
+    expect(prompt).toContain("Contexto e Entendimento");
+    expect(prompt).toContain("Baby Steps");
+    expect(prompt).toContain("Decisoes Arquiteturais");
+  });
+});
+
+describe("buildDevilAdvocatePrompt", () => {
+  it("inclui explicacao de entrega automatica de mensagens", () => {
+    const prompt = buildDevilAdvocatePrompt({ name: "Add auth" });
+    expect(prompt).toContain("entregues automaticamente");
+    expect(prompt).toContain("sem precisar");
+    expect(prompt).toContain("polling");
+  });
+
+  it("instrui a aguardar AMBAS propostas", () => {
+    const prompt = buildDevilAdvocatePrompt({ name: "Add auth" });
+    expect(prompt).toContain("AMBAS as propostas");
+  });
+
+  it("inclui formato estruturado de critica", () => {
+    const prompt = buildDevilAdvocatePrompt({ name: "Add auth" });
+    expect(prompt).toContain("Pontos Fortes");
+    expect(prompt).toContain("Pontos Fracos");
+    expect(prompt).toContain("FORTE | VIAVEL | FRACO");
+  });
+
+  it("inclui instrucao de IGNORE task list nativa", () => {
+    const prompt = buildDevilAdvocatePrompt({ name: "Add auth" });
+    expect(prompt).toContain("IGNORE a task list nativa");
+  });
+});