@codexa/cli 9.0.9 → 9.0.10

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/db/schema.ts

@@ -480,6 +480,13 @@ const MIGRATIONS: Migration[] = [
       db.exec(`ALTER TABLE project ADD COLUMN typecheck_command TEXT`);
     },
   },
+  {
+    version: "9.8.0",
+    description: "Adicionar grepai_workspace na tabela project para suporte a workspace cross-project",
+    up: (db) => {
+      db.exec(`ALTER TABLE project ADD COLUMN grepai_workspace TEXT`);
+    },
+  },
 ];
 
 export function runMigrations(): void {

package/detectors/go.ts

@@ -55,6 +55,37 @@ function parseGoMod(content: string): GoMod {
   return result;
 }
 
+interface GoWork {
+  goVersion?: string;
+  uses: string[];
+}
+
+function parseGoWork(content: string): GoWork {
+  const result: GoWork = { uses: [] };
+
+  const goMatch = content.match(/^go\s+(\d+\.\d+(?:\.\d+)?)$/m);
+  if (goMatch) result.goVersion = goMatch[1];
+
+  // Parse use block: use ( ./path1 \n ./path2 )
+  const useBlockMatch = content.match(/use\s*\(([\s\S]*?)\)/);
+  if (useBlockMatch) {
+    for (const line of useBlockMatch[1].split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("//")) {
+        result.uses.push(trimmed);
+      }
+    }
+  }
+
+  // Parse single-line: use ./path
+  const singleUses = content.matchAll(/^use\s+(\S+)\s*$/gm);
+  for (const match of singleUses) {
+    result.uses.push(match[1].trim());
+  }
+
+  return result;
+}
+
 const goDetector: Detector = {
   name: "go",
   ecosystem: "go",
@@ -117,12 +148,35 @@ const goDetector: Detector = {
       category: "runtime",
     });
 
-    // Create dependency lookup
+    // Create dependency lookup from root go.mod
     const deps = new Map<string, string>();
     for (const req of goMod.require) {
       deps.set(req.path, req.version);
     }
 
+    // Merge workspace module dependencies from go.work
+    const goWorkPath = join(cwd, "go.work");
+    if (fileExists(goWorkPath)) {
+      const goWorkContent = readText(goWorkPath);
+      if (goWorkContent) {
+        const goWork = parseGoWork(goWorkContent);
+        for (const usePath of goWork.uses) {
+          const wsModPath = join(cwd, usePath, "go.mod");
+          if (fileExists(wsModPath)) {
+            const wsContent = readText(wsModPath);
+            if (wsContent) {
+              const wsMod = parseGoMod(wsContent);
+              for (const req of wsMod.require) {
+                if (!deps.has(req.path)) {
+                  deps.set(req.path, req.version);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
     // Web Framework Detection
     const webFrameworks = [
       { paths: ["github.com/gin-gonic/gin"], name: "Gin", confidence: 1.0 },

package/detectors/node.ts

@@ -22,6 +22,32 @@ import {
   readText,
 } from "./index";
 
+/**
+ * Resolve workspace glob patterns from package.json workspaces or pnpm-workspace.yaml.
+ * Returns array of glob patterns (e.g. ["apps/*", "packages/*"]).
+ */
+function resolveWorkspacePatterns(cwd: string, pkg: PackageJson): string[] {
+  // npm/yarn: workspaces as array or { packages: [] }
+  if (pkg.workspaces) {
+    if (Array.isArray(pkg.workspaces)) return pkg.workspaces;
+    if (pkg.workspaces.packages) return pkg.workspaces.packages;
+  }
+
+  // pnpm: pnpm-workspace.yaml
+  const pnpmPath = join(cwd, "pnpm-workspace.yaml");
+  const content = readText(pnpmPath);
+  if (content) {
+    const patterns: string[] = [];
+    for (const line of content.split("\n")) {
+      const match = line.match(/^\s*-\s*['"]?([^'"#]+)['"]?\s*$/);
+      if (match) patterns.push(match[1].trim());
+    }
+    return patterns;
+  }
+
+  return [];
+}
+
 interface PackageJson {
   name?: string;
   version?: string;
@@ -93,12 +119,24 @@ const nodeDetector: Detector = {
     const pkg: PackageJson | null = readJson(pkgPath);
     if (!pkg) return null;
 
-    const allDeps = {
+    const allDeps: Record<string, string> = {
       ...pkg.dependencies,
       ...pkg.devDependencies,
       ...pkg.peerDependencies,
     };
 
+    // Merge workspace package dependencies
+    const workspacePatterns = resolveWorkspacePatterns(cwd, pkg);
+    for (const pattern of workspacePatterns) {
+      const pkgFiles = findFiles(cwd, `${pattern}/package.json`);
+      for (const relPath of pkgFiles) {
+        const wsPkg: PackageJson | null = readJson(join(cwd, relPath));
+        if (wsPkg) {
+          Object.assign(allDeps, wsPkg.dependencies, wsPkg.devDependencies);
+        }
+      }
+    }
+
     // Detect package manager from lock files
     if (fileExists(join(cwd, "bun.lockb"))) {
       technologies.push({

package/gates/standards-validator.ts

@@ -1,7 +1,7 @@
 import { getDb } from "../db/connection";
 import { existsSync, readFileSync } from "fs";
 import { basename, resolve } from "path";
-import { isGrepaiAvailable, searchWithGrepai, type GrepaiResult } from "../commands/patterns";
+import { isGrepaiAvailable, searchWithGrepai, getGrepaiWorkspace, type GrepaiResult } from "../commands/patterns";
 
 // ═══════════════════════════════════════════════════════════════
 // INTERFACES
@@ -119,10 +119,11 @@ function validateSemantic(
   violations: Violation[],
   warnings: Violation[]
 ): void {
+  const workspace = getGrepaiWorkspace() ?? undefined;
   for (const std of standards) {
     if (!std.semantic_query) continue;
 
-    const results = searchWithGrepai(std.semantic_query, 20);
+    const results = searchWithGrepai(std.semantic_query, 20, workspace);
 
     // Filtrar: apenas arquivos sendo validados + score acima do threshold
     const matchingFiles = results.filter(r => {

package/package.json

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

package/workflow.ts

@@ -23,7 +23,9 @@ import {
   discoverRefreshPatterns,
   discoverExportPatterns,
   discoverIncremental,
+  ensureDeepExploreAgent,
 } from "./commands/discover";
+import { isValidWorkspaceName } from "./commands/patterns";
 import { clearTasks, clearShow } from "./commands/clear";
 import { standardsList, standardsAdd, standardsEdit, standardsRemove, standardsExport } from "./commands/standards";
 import { productImport, productSet, productConfirm, productShow, productReset } from "./commands/product";
@@ -553,6 +555,7 @@ discoverCmd
   .option("--auth <value>", "Auth (supabase, next-auth, clerk)")
   .option("--testing <value>", "Testing (vitest, jest, playwright)")
   .option("--typecheck-command <cmd>", "Comando custom de typecheck (ex: 'mypy --strict', 'go vet ./...'). Vazio para usar preset automatico.")
+  .option("--grepai-workspace <name>", "Nome do workspace grepai para busca semantica cross-project. Vazio para remover.")
   .action((options) => {
     // Tratar typecheck-command separadamente
     if (options.typecheckCommand !== undefined) {
@@ -569,9 +572,32 @@ discoverCmd
       }
       console.log("  Sera usado no gate 4.5 (typecheck-pass) em cada task done.\n");
     }
+    // Tratar grepai-workspace separadamente
+    if (options.grepaiWorkspace !== undefined) {
+      const { initSchema } = require("./db/schema");
+      const { getDb } = require("./db/connection");
+      initSchema();
+      const db = getDb();
+      const value = options.grepaiWorkspace === "" ? null : options.grepaiWorkspace;
+      if (value && !isValidWorkspaceName(value)) {
+        console.error(`\n[erro] Nome de workspace invalido: "${value}"`);
+        console.error("  Use apenas letras, numeros, hifens e underscores (ex: meu-workspace, dotnet_ws)\n");
+        return;
+      }
+      db.run("UPDATE project SET grepai_workspace = ? WHERE id = 'default'", [value]);
+      if (value) {
+        console.log(`\n✓ Grepai workspace configurado: ${value}`);
+        console.log("  Sera usado em: semantic search (standards), deep-explore agent, grepai trace");
+      } else {
+        console.log(`\n✓ Grepai workspace removido (usando index local .grepai/)`);
+      }
+      // Auto-regenerate deep-explore agent with new workspace config
+      ensureDeepExploreAgent();
+    }
     // Tratar stack options normalmente
     const stackOptions = { ...options };
     delete stackOptions.typecheckCommand;
+    delete stackOptions.grepaiWorkspace;
     if (Object.keys(stackOptions).length > 0) {
       discoverSetStack(stackOptions);
     }