@codexa/cli 9.0.7 → 9.0.9

package/commands/patterns.ts

@@ -1,14 +1,12 @@
 /**
- * Codexa Workflow v8.0 - Extração Automática de Patterns via Grepai
+ * Codexa Workflow - Patterns & Utilities
  *
- * Usa busca semântica (grepai search) para encontrar arquivos por intenção
- * e extrair patterns de código automaticamente.
+ * Grepai helpers (busca semântica), análise de arquivos,
+ * extração de utilities (DRY enforcement), e atualização incremental de patterns.
  */
 
-import { execSync, spawnSync } from "child_process";
+import { spawnSync } from "child_process";
 import { readFileSync, existsSync } from "fs";
-import { extname, basename, dirname } from "path";
-import { CodexaError, ValidationError } from "../errors";
 import { getDb } from "../db/connection";
 import { initSchema } from "../db/schema";
 
@@ -16,87 +14,17 @@ import { initSchema } from "../db/schema";
 // TIPOS
 // ═══════════════════════════════════════════════════════════════
 
-interface PatternQuery {
-  scope: string;
-  category: string;
-  query: string;
-  appliesTo: string; // glob pattern
-}
-
-interface ExtractedPattern {
-  category: string;
-  name: string;
-  scope: string;
-  appliesTo: string;
-  structure: {
-    commonImports: string[];
-    commonExports: string[];
-    conventions: string[];
-    // v9.0
-    commonHooks: string[];
-    commonReactPatterns: string[];
-    hasTypes: boolean;
-  };
-  template: string;
-  examples: Array<{ path: string; relevance: number }>;
-  antiPatterns: string[];
-  confidence: number;
-  extractedFrom: number;
-}
-
-interface GrepaiResult {
+export interface GrepaiResult {
   path: string;
   score: number;
   content?: string;
 }
 
-// ═══════════════════════════════════════════════════════════════
-// QUERIES SEMÂNTICAS POR ESCOPO
-// ═══════════════════════════════════════════════════════════════
-
-const PATTERN_QUERIES: PatternQuery[] = [
-  // Frontend
-  { scope: "frontend", category: "component", query: "React page component with layout", appliesTo: "app/**/page.tsx" },
-  { scope: "frontend", category: "component", query: "React client component with state", appliesTo: "components/**/*.tsx" },
-  { scope: "frontend", category: "hook", query: "custom React hook with useState", appliesTo: "hooks/**/*.ts" },
-  { scope: "frontend", category: "component", query: "React server component with async data", appliesTo: "app/**/*.tsx" },
-
-  // Backend
-  { scope: "backend", category: "route", query: "API route handler with request response", appliesTo: "app/api/**/*.ts" },
-  { scope: "backend", category: "service", query: "service class with methods", appliesTo: "services/**/*.ts" },
-  { scope: "backend", category: "action", query: "server action with use server", appliesTo: "actions/**/*.ts" },
-
-  // Database
-  { scope: "database", category: "schema", query: "database schema definition", appliesTo: "db/**/*.ts" },
-  { scope: "database", category: "schema", query: "drizzle table schema", appliesTo: "schema/**/*.ts" },
-
-  // Testing
-  { scope: "testing", category: "test", query: "test file with describe and it", appliesTo: "**/*.test.ts" },
-  { scope: "testing", category: "test", query: "vitest test with expect", appliesTo: "**/*.spec.ts" },
-
-  // v9.0: Data Fetching
-  { scope: "frontend", category: "data-fetching", query: "data fetching with loading and error states", appliesTo: "**/*.{tsx,ts}" },
-  { scope: "backend", category: "data-fetching", query: "server action that fetches or mutates data", appliesTo: "actions/**/*.ts" },
-
-  // v9.0: State Management
-  { scope: "frontend", category: "state-management", query: "shared state store context provider or global state", appliesTo: "**/*.{ts,tsx}" },
-
-  // v9.0: Error Handling
-  { scope: "frontend", category: "error-handling", query: "error handling with try catch error boundary or validation", appliesTo: "**/*.{ts,tsx}" },
-  { scope: "backend", category: "error-handling", query: "API error handling with status codes and error responses", appliesTo: "app/api/**/*.ts" },
-
-  // v9.0: Composition
-  { scope: "frontend", category: "composition", query: "component composition with children slots or render props", appliesTo: "components/**/*.tsx" },
-
-  // v9.0: API Integration
-  { scope: "backend", category: "api-integration", query: "external API integration with fetch axios or SDK", appliesTo: "**/*.ts" },
-];
-
 // ═══════════════════════════════════════════════════════════════
 // VERIFICAR GREPAI
 // ═══════════════════════════════════════════════════════════════
 
-function isGrepaiAvailable(): boolean {
+export function isGrepaiAvailable(): boolean {
   try {
     const result = spawnSync("grepai", ["help"], { encoding: "utf-8", timeout: 5000 });
     return !result.error;
@@ -109,7 +37,7 @@ function isGrepaiAvailable(): boolean {
 // BUSCA SEMÂNTICA
 // ═══════════════════════════════════════════════════════════════
 
-function searchWithGrepai(query: string, topK: number = 10): GrepaiResult[] {
+export function searchWithGrepai(query: string, topK: number = 10): GrepaiResult[] {
   try {
     const result = spawnSync(
       "grepai",
@@ -144,7 +72,6 @@ interface FileAnalysis {
   hasNamedExports: boolean;
   conventions: string[];
   size: number;
-  // v9.0: Metadata complementar ao grepai
   directives: string[];
   hooksUsed: string[];
   reactPatterns: string[];
@@ -350,571 +277,8 @@ export function inferScopeFromPath(filePath: string): string {
   return "shared";
 }
 
-function findCommonElements<T>(arrays: T[][]): T[] {
-  if (arrays.length === 0) return [];
-  if (arrays.length === 1) return arrays[0];
-
-  // Elementos que aparecem em pelo menos 50% dos arquivos
-  const threshold = Math.ceil(arrays.length * 0.5);
-  const counts = new Map<string, number>();
-
-  for (const arr of arrays) {
-    const seen = new Set<string>();
-    for (const item of arr) {
-      const key = String(item);
-      if (!seen.has(key)) {
-        seen.add(key);
-        counts.set(key, (counts.get(key) || 0) + 1);
-      }
-    }
-  }
-
-  return [...counts.entries()]
-    .filter(([_, count]) => count >= threshold)
-    .map(([item]) => item as unknown as T);
-}
-
-// ═══════════════════════════════════════════════════════════════
-// GERAÇÃO DE TEMPLATE
-// ═══════════════════════════════════════════════════════════════
-
-function generateTemplate(analyses: FileAnalysis[], category: string): string {
-  const commonImports = findCommonElements(analyses.map((a) => a.imports));
-  const commonHooks = findCommonElements(analyses.map((a) => a.hooksUsed));
-  const hasUseClient = analyses.some((a) => a.directives.includes("use client"));
-  const hasUseServer = analyses.some((a) => a.directives.includes("use server"));
-  const hasUseCache = analyses.some((a) => a.directives.includes("use cache"));
-  const hasAsync = analyses.some((a) => a.conventions.includes("async"));
-  const hasForwardRef = analyses.some((a) => a.reactPatterns.includes("forwardRef"));
-  const hasTypes = analyses.filter((a) => a.hasTypeExports).length > analyses.length * 0.5;
-
-  let template = "";
-
-  // Diretiva
-  if (hasUseClient) {
-    template += `"use client"\n\n`;
-  } else if (hasUseServer) {
-    template += `"use server"\n\n`;
-  } else if (hasUseCache) {
-    template += `"use cache"\n\n`;
-  }
-
-  // Imports comuns (max 5)
-  if (commonImports.length > 0) {
-    for (const imp of commonImports.slice(0, 5)) {
-      if (imp.startsWith("react") || imp.startsWith("next")) {
-        template += `import { /* ... */ } from "${imp}"\n`;
-      } else if (imp.startsWith("@/") || imp.startsWith("~/")) {
-        template += `import { /* ... */ } from "${imp}"\n`;
-      }
-    }
-    template += "\n";
-  }
-
-  // Estrutura baseada na categoria + dados reais dos arquivos
-  switch (category) {
-    case "component": {
-      const propsType = hasForwardRef
-        ? `interface {{ComponentName}}Props extends React.ComponentPropsWithRef<"div">`
-        : `interface {{ComponentName}}Props`;
-      template += `${propsType} {\n  // Props\n}\n\n`;
-
-      if (hasForwardRef) {
-        template += `const {{ComponentName}} = React.forwardRef<HTMLDivElement, {{ComponentName}}Props>(\n  function {{ComponentName}}({ /* props */ }, ref) {\n`;
-      } else if (hasAsync) {
-        template += `export default async function {{ComponentName}}({ /* props */ }: {{ComponentName}}Props) {\n`;
-      } else {
-        template += `export default function {{ComponentName}}({ /* props */ }: {{ComponentName}}Props) {\n`;
-      }
-
-      if (commonHooks.length > 0) {
-        for (const hook of commonHooks.slice(0, 3)) {
-          template += `  // ${hook}(...)\n`;
-        }
-        template += "\n";
-      }
-
-      template += `  return (\n    <div>\n      {/* JSX */}\n    </div>\n  )\n}`;
-
-      if (hasForwardRef) {
-        template += `\n)\n\n{{ComponentName}}.displayName = "{{ComponentName}}"`;
-      }
-      break;
-    }
-
-    case "hook":
-      template += `export function use{{HookName}}() {\n`;
-      if (commonHooks.length > 0) {
-        for (const hook of commonHooks.slice(0, 3)) {
-          template += `  // ${hook}(...)\n`;
-        }
-        template += "\n";
-      }
-      template += `  return {\n    // Valores e funcoes\n  }\n}`;
-      break;
-
-    case "route":
-      template += `import { NextRequest, NextResponse } from "next/server"\n\n`;
-      template += `export async function GET(request: NextRequest) {\n  // Implementacao GET\n  return NextResponse.json({ /* data */ })\n}\n\n`;
-      template += `export async function POST(request: NextRequest) {\n  // Implementacao POST\n  return NextResponse.json({ /* data */ })\n}`;
-      break;
-
-    case "service":
-      template += `export class {{ServiceName}}Service {\n  constructor() {\n    // Inicializacao\n  }\n\n  async execute() {\n    // Logica do servico\n  }\n}`;
-      break;
-
-    case "action":
-      template += `"use server"\n\n`;
-      template += `export async function {{actionName}}(formData: FormData) {\n  // Validacao\n  \n  // Logica\n  \n  // Retorno\n}`;
-      break;
-
-    case "schema":
-      template += `import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"\n\n`;
-      template += `export const {{tableName}} = pgTable("{{table_name}}", {\n  id: uuid("id").primaryKey().defaultRandom(),\n  // Colunas\n  createdAt: timestamp("created_at").defaultNow(),\n  updatedAt: timestamp("updated_at").defaultNow(),\n})`;
-      if (hasTypes) {
-        template += `\n\nexport type {{TableName}} = typeof {{tableName}}.$inferSelect\nexport type New{{TableName}} = typeof {{tableName}}.$inferInsert`;
-      }
-      break;
-
-    case "test":
-      template += `import { describe, it, expect } from "vitest"\n\n`;
-      template += `describe("{{TestSubject}}", () => {\n  it("should do something", () => {\n    // Arrange\n    \n    // Act\n    \n    // Assert\n    expect(true).toBe(true)\n  })\n})`;
-      break;
-
-    case "data-fetching":
-      if (hasUseClient) {
-        template += `// Data fetching pattern (client)\n`;
-        if (commonHooks.some(h => h === "useQuery" || h === "useSWR")) {
-          template += `export function use{{Name}}() {\n  // ${commonHooks.filter(h => h.startsWith("use")).join(", ")}\n}`;
-        } else {
-          template += `export function use{{Name}}() {\n  // Fetch logic\n}`;
-        }
-      } else {
-        template += `// Data fetching pattern (server)\nexport async function {{name}}() {\n  // Fetch data\n}`;
-      }
-      break;
-
-    case "state-management":
-      template += `// State management pattern\n`;
-      if (commonHooks.length > 0) {
-        template += `// Hooks: ${commonHooks.join(", ")}\n`;
-      }
-      break;
-
-    case "error-handling":
-      template += `// Error handling pattern\n`;
-      break;
-
-    case "composition":
-      template += `// Composition pattern\n`;
-      break;
-
-    case "api-integration":
-      template += `// API integration pattern\n`;
-      break;
-
-    default:
-      template += `// Template para ${category}\n`;
-  }
-
-  return template;
-}
-
-// ═══════════════════════════════════════════════════════════════
-// EXTRAÇÃO DE PATTERNS
-// ═══════════════════════════════════════════════════════════════
-
-function extractPatternFromFiles(
-  query: PatternQuery,
-  files: GrepaiResult[]
-): ExtractedPattern | null {
-  if (files.length < 2) {
-    // Precisa de pelo menos 2 arquivos para identificar pattern
-    return null;
-  }
-
-  // Analisar cada arquivo
-  const analyses: FileAnalysis[] = [];
-  for (const file of files) {
-    const analysis = analyzeFile(file.path);
-    if (analysis) {
-      analyses.push(analysis);
-    }
-  }
-
-  if (analyses.length < 2) return null;
-
-  // Encontrar elementos comuns
-  const commonImports = findCommonElements(analyses.map((a) => a.imports));
-  const commonExports = findCommonElements(analyses.map((a) => a.exports));
-  const commonConventions = findCommonElements(analyses.map((a) => a.conventions));
-  // v9.0
-  const commonHooks = findCommonElements(analyses.map((a) => a.hooksUsed));
-  const commonReactPatterns = findCommonElements(analyses.map((a) => a.reactPatterns));
-  const hasTypes = analyses.filter((a) => a.hasTypeExports).length > analyses.length * 0.5;
-
-  // Gerar template
-  const template = generateTemplate(analyses, query.category);
-
-  // Calcular confianca baseada em quantos arquivos seguem o pattern
-  const confidence = Math.min(analyses.length / 10, 1); // Max 1.0 com 10+ arquivos
-
-  // Gerar nome unico
-  const name = `${query.scope}-${query.category}-pattern`;
-
-  return {
-    category: query.category,
-    name: name,
-    scope: query.scope,
-    appliesTo: query.appliesTo,
-    structure: {
-      commonImports,
-      commonExports,
-      conventions: commonConventions,
-      commonHooks,
-      commonReactPatterns,
-      hasTypes,
-    },
-    template,
-    examples: files.slice(0, 5).map((f) => ({
-      path: f.path,
-      relevance: f.score || 0.8,
-    })),
-    antiPatterns: [],
-    confidence,
-    extractedFrom: analyses.length,
-  };
-}
-
-// ═══════════════════════════════════════════════════════════════
-// COMANDOS PÚBLICOS
-// ═══════════════════════════════════════════════════════════════
-
-export interface ExtractOptions {
-  scope?: string;
-  all?: boolean;
-  json?: boolean;
-  dryRun?: boolean;
-}
-
-export function patternsExtract(options: ExtractOptions): void {
-  initSchema();
-
-  // Verificar grepai
-  if (!isGrepaiAvailable()) {
-    throw new CodexaError("grepai nao encontrado.\nInstale com: go install github.com/your-org/grepai@latest\nOu configure no PATH.");
-  }
-
-  const db = getDb();
-  const now = new Date().toISOString();
-
-  // Filtrar queries por escopo
-  let queries = PATTERN_QUERIES;
-  if (options.scope && !options.all) {
-    queries = queries.filter((q) => q.scope === options.scope);
-  }
-
-  if (queries.length === 0) {
-    throw new ValidationError("Escopo '" + options.scope + "' nao reconhecido.\nEscopos validos: frontend, backend, database, testing");
-  }
-
-  console.log(`\n🔍 Extraindo patterns via grepai...`);
-  console.log(`   Queries: ${queries.length}`);
-  console.log(`   Escopo: ${options.scope || "todos"}\n`);
-
-  const extracted: ExtractedPattern[] = [];
-
-  for (const query of queries) {
-    console.log(`  [${query.scope}/${query.category}] "${query.query}"`);
-
-    // Buscar arquivos via grepai
-    const results = searchWithGrepai(query.query, 15);
-
-    if (results.length === 0) {
-      console.log(`    → Nenhum arquivo encontrado`);
-      continue;
-    }
-
-    console.log(`    → ${results.length} arquivos encontrados`);
-
-    // Extrair pattern
-    const pattern = extractPatternFromFiles(query, results);
-
-    if (pattern) {
-      extracted.push(pattern);
-      console.log(`    ✓ Pattern extraido (confiança: ${(pattern.confidence * 100).toFixed(0)}%)`);
-    } else {
-      console.log(`    → Arquivos insuficientes para pattern`);
-    }
-  }
-
-  console.log(`\n${"─".repeat(50)}`);
-  console.log(`Patterns extraidos: ${extracted.length}`);
-
-  if (extracted.length === 0) {
-    console.log("Nenhum pattern encontrado. Execute 'grepai index' primeiro.\n");
-    return;
-  }
-
-  // Output JSON se solicitado
-  if (options.json) {
-    console.log(JSON.stringify({ patterns: extracted }, null, 2));
-    return;
-  }
-
-  // Dry run - apenas mostrar
-  if (options.dryRun) {
-    console.log("\n[DRY RUN] Patterns que seriam salvos:");
-    for (const p of extracted) {
-      console.log(`  - ${p.name} (${p.scope}/${p.category})`);
-      console.log(`    Exemplos: ${p.examples.length}`);
-      console.log(`    Confiança: ${(p.confidence * 100).toFixed(0)}%`);
-    }
-    console.log("\nUse sem --dry-run para salvar no banco.\n");
-    return;
-  }
-
-  // Salvar no banco
-  console.log("\nSalvando patterns no banco...");
-
-  for (const pattern of extracted) {
-    // Verificar se já existe
-    const existing = db
-      .query("SELECT id FROM implementation_patterns WHERE name = ?")
-      .get(pattern.name);
-
-    if (existing) {
-      // Atualizar
-      db.run(
-        `UPDATE implementation_patterns SET
-          structure = ?, template = ?, examples = ?,
-          confidence = ?, extracted_from = ?, updated_at = ?
-        WHERE name = ?`,
-        [
-          JSON.stringify(pattern.structure),
-          pattern.template,
-          JSON.stringify(pattern.examples),
-          pattern.confidence,
-          pattern.extractedFrom,
-          now,
-          pattern.name,
-        ]
-      );
-      console.log(`  ✓ Atualizado: ${pattern.name}`);
-    } else {
-      // Inserir novo
-      db.run(
-        `INSERT INTO implementation_patterns
-          (category, name, scope, applies_to, structure, template, examples, anti_patterns, confidence, extracted_from, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          pattern.category,
-          pattern.name,
-          pattern.scope,
-          pattern.appliesTo,
-          JSON.stringify(pattern.structure),
-          pattern.template,
-          JSON.stringify(pattern.examples),
-          JSON.stringify(pattern.antiPatterns),
-          pattern.confidence,
-          pattern.extractedFrom,
-          now,
-        ]
-      );
-      console.log(`  ✓ Criado: ${pattern.name}`);
-    }
-  }
-
-  console.log(`\n${"─".repeat(50)}`);
-  console.log(`✓ ${extracted.length} patterns salvos no banco.`);
-  console.log(`Use 'discover patterns' para visualizar.`);
-  console.log(`Use 'discover export-patterns' para gerar patterns.md\n`);
-}
-
-export function patternsAnalyze(filePath: string, json: boolean = false): void {
-  if (!existsSync(filePath)) {
-    throw new CodexaError("Arquivo nao encontrado: " + filePath);
-  }
-
-  const analysis = analyzeFile(filePath);
-
-  if (!analysis) {
-    throw new CodexaError("Nao foi possivel analisar o arquivo.");
-  }
-
-  if (json) {
-    console.log(JSON.stringify(analysis, null, 2));
-    return;
-  }
-
-  console.log(`\n📄 Analise: ${filePath}`);
-  console.log(`${"─".repeat(50)}`);
-  console.log(`\nImports (${analysis.imports.length}):`);
-  for (const imp of analysis.imports) {
-    console.log(`  - ${imp}`);
-  }
-  console.log(`\nExports (${analysis.exports.length}):`);
-  for (const exp of analysis.exports) {
-    console.log(`  - ${exp}`);
-  }
-  console.log(`\nConvencoes:`);
-  console.log(`  - Default export: ${analysis.hasDefaultExport ? "sim" : "nao"}`);
-  console.log(`  - Named exports: ${analysis.hasNamedExports ? "sim" : "nao"}`);
-  console.log(`  - Type exports: ${analysis.hasTypeExports ? "sim" : "nao"}`);
-  if (analysis.directives.length > 0) {
-    console.log(`  - Directives: ${analysis.directives.join(", ")}`);
-  }
-  if (analysis.hooksUsed.length > 0) {
-    console.log(`  - Hooks: ${analysis.hooksUsed.join(", ")}`);
-  }
-  if (analysis.reactPatterns.length > 0) {
-    console.log(`  - React patterns: ${analysis.reactPatterns.join(", ")}`);
-  }
-  if (analysis.conventions.length > 0) {
-    console.log(`  - Convencoes: ${analysis.conventions.join(", ")}`);
-  }
-  console.log(`\nTamanho: ${analysis.size} bytes\n`);
-}
-
-// ═══════════════════════════════════════════════════════════════
-// v9.0: ANTI-PATTERNS DE GATE BYPASSES
-// ═══════════════════════════════════════════════════════════════
-
-export function extractAntiPatternsFromHistory(): void {
-  initSchema();
-  const db = getDb();
-
-  const bypasses = db.query(
-    "SELECT * FROM gate_bypasses ORDER BY created_at DESC LIMIT 50"
-  ).all() as any[];
-
-  const antiPatterns: Map<string, { pattern: string; count: number; source: string }> = new Map();
-
-  for (const bypass of bypasses) {
-    if (!bypass.reason) continue;
-
-    const key = `${bypass.gate_name}:${bypass.reason}`;
-    const existing = antiPatterns.get(key);
-
-    if (existing) {
-      existing.count++;
-    } else {
-      const prefix = bypass.gate_name === "dry-check" ? "DRY" : "Evite";
-      antiPatterns.set(key, {
-        pattern: `${prefix}: ${bypass.reason} (gate ${bypass.gate_name})`,
-        count: 1,
-        source: bypass.gate_name,
-      });
-    }
-  }
-
-  const now = new Date().toISOString();
-  let saved = 0;
-
-  for (const [, ap] of antiPatterns) {
-    if (ap.count < 2) continue;
-
-    const allPatterns = db.query("SELECT * FROM implementation_patterns").all() as any[];
-
-    for (const pattern of allPatterns) {
-      const currentAnti: string[] = pattern.anti_patterns ? JSON.parse(pattern.anti_patterns) : [];
-      if (!currentAnti.includes(ap.pattern)) {
-        currentAnti.push(ap.pattern);
-        db.run(
-          "UPDATE implementation_patterns SET anti_patterns = ?, updated_at = ? WHERE id = ?",
-          [JSON.stringify(currentAnti), now, pattern.id]
-        );
-        saved++;
-        break;
-      }
-    }
-  }
-
-  console.log(`\nAnti-patterns extraidos do historico: ${antiPatterns.size}`);
-  console.log(`Anti-patterns recorrentes (>=2x): ${[...antiPatterns.values()].filter(a => a.count >= 2).length}`);
-  console.log(`Anti-patterns salvos em patterns: ${saved}`);
-  console.log(`\nFonte: ${bypasses.length} gate bypasses analisados\n`);
-}
-
-// ═══════════════════════════════════════════════════════════════
-// v9.0: ANALISE PROFUNDA (analyze-deep)
-// ═══════════════════════════════════════════════════════════════
-
-export function patternsAnalyzeDeep(files: string[], json: boolean = false): void {
-  const analyses: FileAnalysis[] = [];
-
-  for (const file of files) {
-    const analysis = analyzeFile(file);
-    if (analysis) analyses.push(analysis);
-  }
-
-  if (analyses.length === 0) {
-    throw new CodexaError("Nenhum arquivo analisado.");
-  }
-
-  const summary = {
-    filesAnalyzed: analyses.length,
-    directives: aggregateItems(analyses.flatMap(a => a.directives)),
-    hooks: aggregateItems(analyses.flatMap(a => a.hooksUsed)),
-    reactPatterns: aggregateItems(analyses.flatMap(a => a.reactPatterns)),
-    conventions: aggregateItems(analyses.flatMap(a => a.conventions)),
-    topImports: aggregateItems(analyses.flatMap(a => a.imports)),
-    hasTypeExports: analyses.filter(a => a.hasTypeExports).length,
-  };
-
-  if (json) {
-    console.log(JSON.stringify(summary, null, 2));
-    return;
-  }
-
-  console.log(`\nAnalise Profunda (${analyses.length} arquivos)`);
-  console.log("=".repeat(50));
-  printAggregation("Directives", summary.directives);
-  printAggregation("Hooks Usados", summary.hooks);
-  printAggregation("React Patterns", summary.reactPatterns);
-  printAggregation("Convencoes", summary.conventions);
-  printAggregation("Top Imports", Object.fromEntries(
-    Object.entries(summary.topImports).sort(([, a], [, b]) => b - a).slice(0, 10)
-  ));
-  console.log(`\nArquivos com type exports: ${summary.hasTypeExports}/${analyses.length}`);
-
-  if (isGrepaiAvailable() && analyses.length > 0) {
-    const topHooks = Object.keys(summary.hooks).slice(0, 3);
-    if (topHooks.length > 0) {
-      console.log(`\nBuscando arquivos similares via grepai...`);
-      const query = `files using ${topHooks.join(" and ")}`;
-      const similar = searchWithGrepai(query, 5);
-      if (similar.length > 0) {
-        console.log(`Arquivos similares encontrados:`);
-        for (const s of similar) {
-          console.log(`  - ${s.path} (score: ${(s.score || 0).toFixed(2)})`);
-        }
-      }
-    }
-  }
-
-  console.log();
-}
-
-function aggregateItems(items: string[]): Record<string, number> {
-  const counts: Record<string, number> = {};
-  for (const item of items) {
-    counts[item] = (counts[item] || 0) + 1;
-  }
-  return counts;
-}
-
-function printAggregation(title: string, data: Record<string, number>): void {
-  const entries = Object.entries(data);
-  if (entries.length === 0) return;
-  console.log(`\n${title}:`);
-  for (const [name, count] of entries.sort(([, a], [, b]) => b - a)) {
-    console.log(`  - ${name}: ${count}x`);
-  }
-}
-
 // ═══════════════════════════════════════════════════════════════
-// v9.0: ATUALIZACAO INCREMENTAL DE PATTERNS
+// ATUALIZACAO INCREMENTAL DE PATTERNS (chamado por taskDone)
 // ═══════════════════════════════════════════════════════════════
 
 export function updatePatternsIncremental(files: string[], taskNumber: number): void {