@codexa/cli 9.0.9 → 9.0.11

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.11",
   "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";
@@ -38,6 +40,7 @@ import {
   architectExport,
   architectCancel,
 } from "./commands/architect";
+import { teamSuggest } from "./commands/team";
 import { initSchema } from "./db/schema";
 import { getDb, closeDb } from "./db/connection";
 import { execSync } from "child_process";
@@ -553,6 +556,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 +573,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);
     }
@@ -961,6 +988,22 @@ architectCmd
     architectCancel(options);
   });
 
+// ═══════════════════════════════════════════════════════════════
+// AGENT TEAMS (Experimental)
+// ═══════════════════════════════════════════════════════════════
+
+const teamCmd = program.command("team").description("Comandos de Agent Teams (experimental)");
+
+teamCmd
+  .command("suggest")
+  .description("Sugere modo de execucao (team vs subagent) para a fase atual")
+  .option("--json", "Saida em JSON")
+  .option("--phase <phase>", "Fase especifica (imp, rev, architect)")
+  .option("--spec <id>", "ID do spec (padrao: mais recente)")
+  .action(wrapAction((options) => {
+    teamSuggest(options);
+  }));
+
 // ═══════════════════════════════════════════════════════════════
 // PLUGIN
 // ═══════════════════════════════════════════════════════════════