@codexa/cli 8.6.12 → 8.6.14

package/commands/discover.ts

@@ -2,6 +2,8 @@ import { getDb } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
+import { spawnSync } from "child_process";
+import pkg from "../package.json";
 import {
   detectUniversal,
   detectStackLegacy,
@@ -181,9 +183,9 @@ export function discoverConfirm(): void {
   // Mover de pending para default
   db.run("DELETE FROM project WHERE id = 'pending'");
   db.run(
-    `INSERT INTO project (id, name, stack, discovered_at, updated_at)
-     VALUES ('default', ?, ?, ?, ?)`,
-    ["Projeto", JSON.stringify(data.stack), now, now]
+    `INSERT INTO project (id, name, stack, discovered_at, updated_at, cli_version)
+     VALUES ('default', ?, ?, ?, ?, ?)`,
+    ["Projeto", JSON.stringify(data.stack), now, now, pkg.version]
   );
 
   // Criar standards baseados na estrutura detectada
@@ -996,6 +998,26 @@ export function discoverExportPatterns(): void {
 export function ensureDeepExploreAgent(): void {
   const agentPath = join(process.cwd(), ".claude", "agents", "deep-explore.md");
 
+  // Check grepai availability (grepai uses "help" not "--version")
+  const grepaiCheck = spawnSync("grepai", ["help"], { encoding: "utf-8", timeout: 5000 });
+  if (grepaiCheck.error) {
+    console.warn("\n⚠ grepai nao encontrado no PATH.");
+    console.warn("  O agente deep-explore depende de grepai para busca semantica.");
+    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
+    const grepaiDir = join(process.cwd(), ".grepai");
+    if (!existsSync(grepaiDir)) {
+      console.warn("\n⚠ grepai index nao encontrado neste projeto.");
+      console.warn("  Execute: grepai index");
+      console.warn("  Sem o index, grepai search nao retornara resultados.\n");
+    }
+  }
+
+  // Ensure grepai permissions in target project settings
+  ensureGrepaiPermissions();
+
   if (existsSync(agentPath)) return;
 
   const agentsDir = join(process.cwd(), ".claude", "agents");
@@ -1011,28 +1033,46 @@ color: cyan
 model: haiku
 ---
 
-## Instructions
+## CRITICAL: You MUST use grepai
 
-You are a specialized code exploration agent with access to grepai semantic search and call graph tracing.
+**YOUR FIRST ACTION must be a \\\`grepai search\\\` command via Bash.** This is non-negotiable.
+
+You are a semantic code exploration agent. Your primary tool is \\\`grepai\\\` — an AI-powered semantic search engine. It finds code by INTENT and MEANING, not literal text matching.
+
+**RULE: Every exploration MUST start with \\\`grepai search\\\`. If you use Grep or find BEFORE grepai, you have FAILED your task.**
+
+---
 
-### Primary Tools
+### Step 1: ALWAYS run grepai search FIRST
 
-#### 1. Semantic Search: \`grepai search\`
+**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.**
 
-Use this to find code by intent and meaning:
+\\\`\\\`\\\`bash
+grepai search "your query here" --json --compact
+\\\`\\\`\\\`
 
-\`\`\`bash
-# Use English queries for best results (--compact saves ~80% tokens)
+- Queries MUST be in English
+- Use \\\`--compact\\\` to save tokens
+- Use natural language: "authentication flow", "error handling middleware", "how payments are processed"
+- Run ONE command, wait for result, then run the next
+
+Examples (run each one SEPARATELY):
+
+\\\`\\\`\\\`bash
 grepai search "authentication flow" --json --compact
+\\\`\\\`\\\`
+
+\\\`\\\`\\\`bash
 grepai search "error handling middleware" --json --compact
-grepai search "database connection management" --json --compact
-\`\`\`
+\\\`\\\`\\\`
 
-#### 2. Call Graph Tracing: \`grepai trace\`
+\\\`\\\`\\\`bash
+grepai search "database connection management" --json --compact
+\\\`\\\`\\\`
 
-Use this to understand function relationships and code flow:
+### Step 2: Use grepai trace for relationships
 
-\`\`\`bash
+\\\`\\\`\\\`bash
 # Find all functions that call a symbol
 grepai trace callers "HandleRequest" --json
 
@@ -1041,32 +1081,78 @@ grepai trace callees "ProcessOrder" --json
 
 # Build complete call graph
 grepai trace graph "ValidateToken" --depth 3 --json
-\`\`\`
+\\\`\\\`\\\`
+
+### Step 3: Read files identified by grepai
+
+Use \\\`Read\\\` to examine files that grepai found relevant.
+
+### Step 4: Grep ONLY for exact literals (optional)
 
-Use \`grepai trace\` when you need to:
+Use Grep ONLY if you need exact string match (variable name, import path). Never use Grep for exploration — grepai is always better for that.
 
-- Find all callers of a function
-- Understand the call hierarchy
-- Analyze the impact of changes to a function
-- Map dependencies between components
+---
+
+### FORBIDDEN
 
-### When to use standard tools
+- **DO NOT** use \\\`find\\\` or \\\`ls\\\` to explore code — use \\\`grepai search\\\`
+- **DO NOT** use \\\`Grep\\\` for semantic exploration — use \\\`grepai search\\\`
+- **DO NOT** skip grepai and go straight to Read/Grep
+- **DO NOT** write custom exploration logic when grepai can answer it
 
-Only fall back to Grep/Glob when:
+### If grepai fails
 
-- You need exact text matching (variable names, imports)
-- grepai is not available or returns errors
-- You need file path patterns
+If \\\`grepai search\\\` returns an error (command not found, index missing), report this in your response:
 
-### Workflow
+\\\`\\\`\\\`json
+{"status": "blocked", "blockers": ["grepai not available: <error message>"]}
+\\\`\\\`\\\`
 
-1. Start with \`grepai search\` to find relevant code semantically
-2. Use \`grepai trace\` to understand function relationships and call graphs
-3. Use \`Read\` to examine promising files in detail
-4. Use Grep only for exact string searches if needed
-5. Synthesize findings into a clear summary
+Do NOT silently fall back to Grep. The orchestrator needs to know grepai is not working.
 `;
 
   writeFileSync(agentPath, content);
   console.log("✓ Agent deep-explore instalado em .claude/agents/deep-explore.md");
+}
+
+// Ensure grepai Bash permissions exist in the target project's .claude/settings.local.json
+function ensureGrepaiPermissions(): void {
+  const settingsPath = join(process.cwd(), ".claude", "settings.local.json");
+  const claudeDir = join(process.cwd(), ".claude");
+
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+  }
+
+  const requiredPermissions = [
+    "Bash(grepai search:*)",
+    "Bash(grepai trace:*)",
+    "Bash(grepai:*)",
+  ];
+
+  let settings: { permissions?: { allow?: string[] } } = {};
+
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.permissions) settings.permissions = {};
+  if (!settings.permissions.allow) settings.permissions.allow = [];
+
+  let added = false;
+  for (const perm of requiredPermissions) {
+    if (!settings.permissions.allow.includes(perm)) {
+      settings.permissions.allow.push(perm);
+      added = true;
+    }
+  }
+
+  if (added) {
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    console.log("✓ Permissoes de grepai adicionadas em .claude/settings.local.json");
+  }
 }

package/commands/patterns.ts

@@ -76,8 +76,8 @@ const PATTERN_QUERIES: PatternQuery[] = [
 
 function isGrepaiAvailable(): boolean {
   try {
-    const result = spawnSync("grepai", ["--version"], { encoding: "utf-8" });
-    return result.status === 0;
+    const result = spawnSync("grepai", ["help"], { encoding: "utf-8", timeout: 5000 });
+    return !result.error;
   } catch {
     return false;
   }

package/db/schema.ts

@@ -383,6 +383,13 @@ export function initSchema(): void {
   } catch {
     // Coluna ja existe - ignorar
   }
+
+  // v8.7: Migracao - adicionar cli_version na tabela project
+  try {
+    db.exec(`ALTER TABLE project ADD COLUMN cli_version TEXT`);
+  } catch {
+    // Coluna ja existe - ignorar
+  }
 }
 
 export function getPatternsByScope(scope: string): any[] {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "8.6.12",
+  "version": "8.6.14",
   "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

@@ -38,23 +38,60 @@ import {
   architectCancel,
 } from "./commands/architect";
 import { initSchema } from "./db/schema";
+import { getDb } from "./db/connection";
 import { execSync } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import pkg from "./package.json";
 
 function checkVersionSync(): void {
+  // 1. Check CLI vs Plugin (dev repo only)
   try {
     const gitRoot = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
     const pluginJson = join(gitRoot, "plugins", "codexa-workflow", ".claude-plugin", "plugin.json");
-    if (!existsSync(pluginJson)) return;
-    const plugin = JSON.parse(readFileSync(pluginJson, "utf-8"));
-    if (plugin.version && plugin.version !== pkg.version) {
-      console.warn(`\n⚠  Versao desatualizada: CLI=${pkg.version} Plugin=${plugin.version}`);
-      console.warn(`   Atualize o CLI: bun add -g @codexa/cli\n`);
+    if (existsSync(pluginJson)) {
+      const plugin = JSON.parse(readFileSync(pluginJson, "utf-8"));
+      if (plugin.version && plugin.version !== pkg.version) {
+        console.error(`\n✘ Versao incompativel: CLI=${pkg.version} Plugin=${plugin.version}`);
+        console.error(`  O CLI e o plugin DEVEM ter a mesma versao.`);
+        console.error(`  Atualize o CLI: bun add -g @codexa/cli@${plugin.version}\n`);
+        process.exit(1);
+      }
     }
   } catch {
-    // Not in a git repo or plugin not found — skip silently
+    // Not in dev repo — skip
+  }
+
+  // 2. Check CLI vs project's stored version (client projects)
+  try {
+    const dbPath = join(process.cwd(), ".codexa", "db", "workflow.db");
+    if (!existsSync(dbPath)) return;
+
+    initSchema();
+    const db = getDb();
+    const project = db.query("SELECT cli_version FROM project WHERE id = 'default'").get() as any;
+    if (!project) return;
+
+    if (!project.cli_version) {
+      // Projeto existente sem versao gravada (pre-v8.7) — registrar versao atual
+      db.run(
+        `UPDATE project SET cli_version = ? WHERE id = 'default'`,
+        [pkg.version]
+      );
+      console.log(`✓ Versao do CLI (${pkg.version}) registrada no projeto.`);
+      return;
+    }
+
+    if (project.cli_version !== pkg.version) {
+      console.error(`\n✘ Versao incompativel: CLI=${pkg.version} Projeto=${project.cli_version}`);
+      console.error(`  O projeto foi configurado com CLI v${project.cli_version} mas voce esta usando v${pkg.version}.`);
+      console.error(`  Opcoes:`);
+      console.error(`    1. Atualize o CLI: bun add -g @codexa/cli@${project.cli_version}`);
+      console.error(`    2. Reconfigure o projeto: codexa discover reset && codexa discover start\n`);
+      process.exit(1);
+    }
+  } catch {
+    // DB not available or column doesn't exist yet — skip
   }
 }