@codexa/cli 8.5.0 → 8.6.0

package/commands/decide.ts

@@ -1,249 +1,249 @@
-import { getDb } from "../db/connection";
-import { initSchema } from "../db/schema";
-
-function getNextDecisionId(specId: string): string {
-  const db = getDb();
-  const last = db
-    .query("SELECT id FROM decisions WHERE spec_id = ? ORDER BY created_at DESC LIMIT 1")
-    .get(specId) as any;
-
-  if (!last) return "DEC-001";
-
-  const num = parseInt(last.id.replace("DEC-", "")) + 1;
-  return `DEC-${num.toString().padStart(3, "0")}`;
-}
-
-interface ConflictAnalysis {
-  hasConflict: boolean;
-  conflictingDecisions: Array<{
-    id: string;
-    title: string;
-    decision: string;
-    reason: string;
-  }>;
-}
-
-// Extrair keywords relevantes de um texto
-function extractKeywords(text: string): string[] {
-  const stopWords = new Set([
-    "a", "o", "e", "de", "da", "do", "para", "com", "em", "que", "usar",
-    "the", "and", "or", "to", "for", "with", "in", "on", "is", "are", "be",
-    "will", "should", "must", "can", "use", "using", "como", "ser", "sera"
-  ]);
-
-  return text
-    .toLowerCase()
-    .replace(/[^\w\s-]/g, " ")
-    .split(/\s+/)
-    .filter((word) => word.length > 2 && !stopWords.has(word));
-}
-
-// Detectar conflitos semanticos entre decisoes
-function detectConflicts(
-  newTitle: string,
-  newDecision: string,
-  existingDecisions: any[]
-): ConflictAnalysis {
-  const conflicts: ConflictAnalysis["conflictingDecisions"] = [];
-
-  const newKeywords = new Set([
-    ...extractKeywords(newTitle),
-    ...extractKeywords(newDecision),
-  ]);
-
-  // Padroes de conflito conhecidos
-  const conflictPatterns: Array<{ patterns: string[][]; reason: string }> = [
-    {
-      patterns: [["rest", "api"], ["graphql"]],
-      reason: "Conflito de paradigma de API (REST vs GraphQL)",
-    },
-    {
-      patterns: [["jwt", "token"], ["session", "cookie"]],
-      reason: "Conflito de estrategia de autenticacao",
-    },
-    {
-      patterns: [["zustand"], ["redux"]],
-      reason: "Conflito de biblioteca de estado",
-    },
-    {
-      patterns: [["prisma"], ["drizzle"]],
-      reason: "Conflito de ORM",
-    },
-    {
-      patterns: [["mysql"], ["postgres", "postgresql"]],
-      reason: "Conflito de banco de dados",
-    },
-    {
-      patterns: [["server", "component"], ["client", "component"]],
-      reason: "Conflito de tipo de componente padrao",
-    },
-    {
-      patterns: [["tailwind"], ["styled", "component"]],
-      reason: "Conflito de abordagem de styling",
-    },
-    {
-      patterns: [["vitest"], ["jest"]],
-      reason: "Conflito de framework de testes",
-    },
-  ];
-
-  for (const existing of existingDecisions) {
-    const existingKeywords = new Set([
-      ...extractKeywords(existing.title),
-      ...extractKeywords(existing.decision),
-    ]);
-
-    // Verificar padroes de conflito conhecidos
-    for (const { patterns, reason } of conflictPatterns) {
-      const [patternA, patternB] = patterns;
-
-      const newHasA = patternA.some((p) => newKeywords.has(p));
-      const newHasB = patternB.some((p) => newKeywords.has(p));
-      const existingHasA = patternA.some((p) => existingKeywords.has(p));
-      const existingHasB = patternB.some((p) => existingKeywords.has(p));
-
-      // Conflito: nova decisao menciona A, existente menciona B (ou vice-versa)
-      if ((newHasA && existingHasB) || (newHasB && existingHasA)) {
-        conflicts.push({
-          id: existing.id,
-          title: existing.title,
-          decision: existing.decision,
-          reason,
-        });
-        break; // Apenas um conflito por decisao existente
-      }
-    }
-
-    // Verificar sobreposicao alta de keywords (mesmo topico, decisoes diferentes?)
-    if (conflicts.every((c) => c.id !== existing.id)) {
-      const intersection = [...newKeywords].filter((k) => existingKeywords.has(k));
-      const similarity = intersection.length / Math.max(newKeywords.size, existingKeywords.size);
-
-      if (similarity > 0.4 && intersection.length >= 3) {
-        conflicts.push({
-          id: existing.id,
-          title: existing.title,
-          decision: existing.decision,
-          reason: `Alta sobreposicao de topico (${Math.round(similarity * 100)}% similar) - verificar se sao decisoes conflitantes`,
-        });
-      }
-    }
-  }
-
-  return {
-    hasConflict: conflicts.length > 0,
-    conflictingDecisions: conflicts,
-  };
-}
-
-export function decide(title: string, decision: string, options: { rationale?: string; force?: boolean }): void {
-  initSchema();
-
-  const db = getDb();
-  const now = new Date().toISOString();
-
-  const spec = db
-    .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
-    .get() as any;
-
-  if (!spec) {
-    console.error("\nNenhuma feature ativa.\n");
-    process.exit(1);
-  }
-
-  // Verificar conflitos com decisoes existentes
-  const existingDecisions = db
-    .query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'")
-    .all(spec.id) as any[];
-
-  if (existingDecisions.length > 0 && !options.force) {
-    const analysis = detectConflicts(title, decision, existingDecisions);
-
-    if (analysis.hasConflict) {
-      console.warn("\n⚠ POTENCIAL CONFLITO DETECTADO:\n");
-      console.warn(`Nova decisao: "${title}"`);
-      console.warn(`  ${decision}\n`);
-
-      for (const conflict of analysis.conflictingDecisions) {
-        console.warn(`Pode conflitar com: ${conflict.id} - "${conflict.title}"`);
-        console.warn(`  ${conflict.decision}`);
-        console.warn(`  Motivo: ${conflict.reason}\n`);
-      }
-
-      console.warn(`${"─".repeat(50)}`);
-      console.warn(`Para registrar mesmo assim, use: decide "${title}" "${decision}" --force`);
-      console.warn(`Ou revise as decisoes existentes com: decisions\n`);
-      process.exit(1);
-    }
-  }
-
-  // Pegar task atual em execucao
-  const currentTask = db
-    .query("SELECT * FROM tasks WHERE spec_id = ? AND status = 'running' LIMIT 1")
-    .get(spec.id) as any;
-
-  const decisionId = getNextDecisionId(spec.id);
-
-  db.run(
-    `INSERT INTO decisions (id, spec_id, task_ref, title, decision, rationale, status, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, 'active', ?)`,
-    [
-      decisionId,
-      spec.id,
-      currentTask?.number || null,
-      title,
-      decision,
-      options.rationale || null,
-      now,
-    ]
-  );
-
-  console.log(`\nDecisao registrada: ${decisionId}`);
-  console.log(`Titulo: ${title}`);
-  console.log(`Decisao: ${decision}`);
-  if (options.rationale) console.log(`Racional: ${options.rationale}`);
-  if (currentTask) console.log(`Task: #${currentTask.number}`);
-  if (options.force) console.log(`[!] Registrada com --force (conflito ignorado)`);
-  console.log();
-}
-
-export function listDecisions(json: boolean = false): void {
-  initSchema();
-
-  const db = getDb();
-
-  const spec = db
-    .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
-    .get() as any;
-
-  if (!spec) {
-    console.error("\nNenhuma feature ativa.\n");
-    process.exit(1);
-  }
-
-  const decisions = db
-    .query("SELECT * FROM decisions WHERE spec_id = ? ORDER BY created_at")
-    .all(spec.id) as any[];
-
-  if (json) {
-    console.log(JSON.stringify({ decisions }));
-    return;
-  }
-
-  if (decisions.length === 0) {
-    console.log("\nNenhuma decisao registrada.\n");
-    return;
-  }
-
-  console.log(`\nDecisoes (${decisions.length}):`);
-  console.log(`${"─".repeat(60)}`);
-
-  for (const dec of decisions) {
-    const taskRef = dec.task_ref ? ` [Task #${dec.task_ref}]` : "";
-    const status = dec.status === "active" ? "" : ` (${dec.status})`;
-    console.log(`${dec.id}: ${dec.title}${taskRef}${status}`);
-    console.log(`  ${dec.decision}`);
-    if (dec.rationale) console.log(`  Racional: ${dec.rationale}`);
-    console.log();
-  }
-}
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+
+function getNextDecisionId(specId: string): string {
+  const db = getDb();
+  const last = db
+    .query("SELECT id FROM decisions WHERE spec_id = ? ORDER BY created_at DESC LIMIT 1")
+    .get(specId) as any;
+
+  if (!last) return "DEC-001";
+
+  const num = parseInt(last.id.replace("DEC-", "")) + 1;
+  return `DEC-${num.toString().padStart(3, "0")}`;
+}
+
+interface ConflictAnalysis {
+  hasConflict: boolean;
+  conflictingDecisions: Array<{
+    id: string;
+    title: string;
+    decision: string;
+    reason: string;
+  }>;
+}
+
+// Extrair keywords relevantes de um texto
+function extractKeywords(text: string): string[] {
+  const stopWords = new Set([
+    "a", "o", "e", "de", "da", "do", "para", "com", "em", "que", "usar",
+    "the", "and", "or", "to", "for", "with", "in", "on", "is", "are", "be",
+    "will", "should", "must", "can", "use", "using", "como", "ser", "sera"
+  ]);
+
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, " ")
+    .split(/\s+/)
+    .filter((word) => word.length > 2 && !stopWords.has(word));
+}
+
+// Detectar conflitos semanticos entre decisoes
+function detectConflicts(
+  newTitle: string,
+  newDecision: string,
+  existingDecisions: any[]
+): ConflictAnalysis {
+  const conflicts: ConflictAnalysis["conflictingDecisions"] = [];
+
+  const newKeywords = new Set([
+    ...extractKeywords(newTitle),
+    ...extractKeywords(newDecision),
+  ]);
+
+  // Padroes de conflito conhecidos
+  const conflictPatterns: Array<{ patterns: string[][]; reason: string }> = [
+    {
+      patterns: [["rest", "api"], ["graphql"]],
+      reason: "Conflito de paradigma de API (REST vs GraphQL)",
+    },
+    {
+      patterns: [["jwt", "token"], ["session", "cookie"]],
+      reason: "Conflito de estrategia de autenticacao",
+    },
+    {
+      patterns: [["zustand"], ["redux"]],
+      reason: "Conflito de biblioteca de estado",
+    },
+    {
+      patterns: [["prisma"], ["drizzle"]],
+      reason: "Conflito de ORM",
+    },
+    {
+      patterns: [["mysql"], ["postgres", "postgresql"]],
+      reason: "Conflito de banco de dados",
+    },
+    {
+      patterns: [["server", "component"], ["client", "component"]],
+      reason: "Conflito de tipo de componente padrao",
+    },
+    {
+      patterns: [["tailwind"], ["styled", "component"]],
+      reason: "Conflito de abordagem de styling",
+    },
+    {
+      patterns: [["vitest"], ["jest"]],
+      reason: "Conflito de framework de testes",
+    },
+  ];
+
+  for (const existing of existingDecisions) {
+    const existingKeywords = new Set([
+      ...extractKeywords(existing.title),
+      ...extractKeywords(existing.decision),
+    ]);
+
+    // Verificar padroes de conflito conhecidos
+    for (const { patterns, reason } of conflictPatterns) {
+      const [patternA, patternB] = patterns;
+
+      const newHasA = patternA.some((p) => newKeywords.has(p));
+      const newHasB = patternB.some((p) => newKeywords.has(p));
+      const existingHasA = patternA.some((p) => existingKeywords.has(p));
+      const existingHasB = patternB.some((p) => existingKeywords.has(p));
+
+      // Conflito: nova decisao menciona A, existente menciona B (ou vice-versa)
+      if ((newHasA && existingHasB) || (newHasB && existingHasA)) {
+        conflicts.push({
+          id: existing.id,
+          title: existing.title,
+          decision: existing.decision,
+          reason,
+        });
+        break; // Apenas um conflito por decisao existente
+      }
+    }
+
+    // Verificar sobreposicao alta de keywords (mesmo topico, decisoes diferentes?)
+    if (conflicts.every((c) => c.id !== existing.id)) {
+      const intersection = [...newKeywords].filter((k) => existingKeywords.has(k));
+      const similarity = intersection.length / Math.max(newKeywords.size, existingKeywords.size);
+
+      if (similarity > 0.4 && intersection.length >= 3) {
+        conflicts.push({
+          id: existing.id,
+          title: existing.title,
+          decision: existing.decision,
+          reason: `Alta sobreposicao de topico (${Math.round(similarity * 100)}% similar) - verificar se sao decisoes conflitantes`,
+        });
+      }
+    }
+  }
+
+  return {
+    hasConflict: conflicts.length > 0,
+    conflictingDecisions: conflicts,
+  };
+}
+
+export function decide(title: string, decision: string, options: { rationale?: string; force?: boolean }): void {
+  initSchema();
+
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  const spec = db
+    .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
+    .get() as any;
+
+  if (!spec) {
+    console.error("\nNenhuma feature ativa.\n");
+    process.exit(1);
+  }
+
+  // Verificar conflitos com decisoes existentes
+  const existingDecisions = db
+    .query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'")
+    .all(spec.id) as any[];
+
+  if (existingDecisions.length > 0 && !options.force) {
+    const analysis = detectConflicts(title, decision, existingDecisions);
+
+    if (analysis.hasConflict) {
+      console.warn("\n⚠ POTENCIAL CONFLITO DETECTADO:\n");
+      console.warn(`Nova decisao: "${title}"`);
+      console.warn(`  ${decision}\n`);
+
+      for (const conflict of analysis.conflictingDecisions) {
+        console.warn(`Pode conflitar com: ${conflict.id} - "${conflict.title}"`);
+        console.warn(`  ${conflict.decision}`);
+        console.warn(`  Motivo: ${conflict.reason}\n`);
+      }
+
+      console.warn(`${"─".repeat(50)}`);
+      console.warn(`Para registrar mesmo assim, use: decide "${title}" "${decision}" --force`);
+      console.warn(`Ou revise as decisoes existentes com: decisions\n`);
+      process.exit(1);
+    }
+  }
+
+  // Pegar task atual em execucao
+  const currentTask = db
+    .query("SELECT * FROM tasks WHERE spec_id = ? AND status = 'running' LIMIT 1")
+    .get(spec.id) as any;
+
+  const decisionId = getNextDecisionId(spec.id);
+
+  db.run(
+    `INSERT INTO decisions (id, spec_id, task_ref, title, decision, rationale, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, 'active', ?)`,
+    [
+      decisionId,
+      spec.id,
+      currentTask?.number || null,
+      title,
+      decision,
+      options.rationale || null,
+      now,
+    ]
+  );
+
+  console.log(`\nDecisao registrada: ${decisionId}`);
+  console.log(`Titulo: ${title}`);
+  console.log(`Decisao: ${decision}`);
+  if (options.rationale) console.log(`Racional: ${options.rationale}`);
+  if (currentTask) console.log(`Task: #${currentTask.number}`);
+  if (options.force) console.log(`[!] Registrada com --force (conflito ignorado)`);
+  console.log();
+}
+
+export function listDecisions(json: boolean = false): void {
+  initSchema();
+
+  const db = getDb();
+
+  const spec = db
+    .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
+    .get() as any;
+
+  if (!spec) {
+    console.error("\nNenhuma feature ativa.\n");
+    process.exit(1);
+  }
+
+  const decisions = db
+    .query("SELECT * FROM decisions WHERE spec_id = ? ORDER BY created_at")
+    .all(spec.id) as any[];
+
+  if (json) {
+    console.log(JSON.stringify({ decisions }));
+    return;
+  }
+
+  if (decisions.length === 0) {
+    console.log("\nNenhuma decisao registrada.\n");
+    return;
+  }
+
+  console.log(`\nDecisoes (${decisions.length}):`);
+  console.log(`${"─".repeat(60)}`);
+
+  for (const dec of decisions) {
+    const taskRef = dec.task_ref ? ` [Task #${dec.task_ref}]` : "";
+    const status = dec.status === "active" ? "" : ` (${dec.status})`;
+    console.log(`${dec.id}: ${dec.title}${taskRef}${status}`);
+    console.log(`  ${dec.decision}`);
+    if (dec.rationale) console.log(`  Racional: ${dec.rationale}`);
+    console.log();
+  }
+}

package/commands/discover.ts

@@ -265,6 +265,9 @@ export function discoverConfirm(): void {
 
   const standardsCount = db.query("SELECT COUNT(*) as c FROM standards").get() as any;
 
+  // Auto-setup: deep-explore agent
+  ensureDeepExploreAgent();
+
   console.log("\nProjeto descoberto e configurado!");
   console.log(`Standards criados: ${standardsCount.c}`);
   console.log("\nArquivo gerado: .codexa/standards.md");
@@ -455,16 +458,6 @@ export async function discoverRefresh(options: { force?: boolean } = {}): Promis
   }
 }
 
-// Exportar detectStack para uso interno
-export { detectStack, detectStructure, detectFull };
-
-// Re-export detector utilities for advanced usage
-export {
-  detectUniversal,
-  formatDetectionResult,
-  getDetailedTechnologies,
-} from "../detectors/loader";
-
 function generateStandardsMarkdown(): void {
   const db = getDb();
   const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
@@ -997,4 +990,83 @@ export function generatePatternsMarkdown(): void {
 export function discoverExportPatterns(): void {
   generatePatternsMarkdown();
   console.log("\n✓ Arquivo .codexa/patterns.md regenerado!\n");
+}
+
+// Auto-setup: garante que o agent deep-explore existe no projeto
+export function ensureDeepExploreAgent(): void {
+  const agentPath = join(process.cwd(), ".claude", "agents", "deep-explore.md");
+
+  if (existsSync(agentPath)) return;
+
+  const agentsDir = join(process.cwd(), ".claude", "agents");
+  if (!existsSync(agentsDir)) {
+    mkdirSync(agentsDir, { recursive: true });
+  }
+
+  const content = `---
+name: deep-explore
+description: Deep codebase exploration using grepai semantic search and call graph tracing. Use this agent for understanding code architecture, finding implementations by intent, analyzing function relationships, and exploring unfamiliar code areas.
+tools: Read, Grep, Glob, Bash
+color: cyan
+model: haiku
+---
+
+## Instructions
+
+You are a specialized code exploration agent with access to grepai semantic search and call graph tracing.
+
+### Primary Tools
+
+#### 1. Semantic Search: \`grepai search\`
+
+Use this to find code by intent and meaning:
+
+\`\`\`bash
+# Use English queries for best results (--compact saves ~80% tokens)
+grepai search "authentication flow" --json --compact
+grepai search "error handling middleware" --json --compact
+grepai search "database connection management" --json --compact
+\`\`\`
+
+#### 2. Call Graph Tracing: \`grepai trace\`
+
+Use this to understand function relationships and code flow:
+
+\`\`\`bash
+# Find all functions that call a symbol
+grepai trace callers "HandleRequest" --json
+
+# Find all functions called by a symbol
+grepai trace callees "ProcessOrder" --json
+
+# Build complete call graph
+grepai trace graph "ValidateToken" --depth 3 --json
+\`\`\`
+
+Use \`grepai trace\` when you need to:
+
+- Find all callers of a function
+- Understand the call hierarchy
+- Analyze the impact of changes to a function
+- Map dependencies between components
+
+### When to use standard tools
+
+Only fall back to Grep/Glob when:
+
+- You need exact text matching (variable names, imports)
+- grepai is not available or returns errors
+- You need file path patterns
+
+### Workflow
+
+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
+`;
+
+  writeFileSync(agentPath, content);
+  console.log("✓ Agent deep-explore instalado em .claude/agents/deep-explore.md");
 }