@codexa/cli 8.5.0 → 8.6.0

package/commands/patterns.ts

@@ -1,621 +1,621 @@
-/**
- * Codexa Workflow v8.0 - Extração Automática de Patterns via Grepai
- *
- * Usa busca semântica (grepai search) para encontrar arquivos por intenção
- * e extrair patterns de código automaticamente.
- */
-
-import { execSync, spawnSync } from "child_process";
-import { readFileSync, existsSync } from "fs";
-import { extname, basename, dirname } from "path";
-import { getDb } from "../db/connection";
-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[];
-  };
-  template: string;
-  examples: Array<{ path: string; relevance: number }>;
-  antiPatterns: string[];
-  confidence: number;
-  extractedFrom: number;
-}
-
-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" },
-];
-
-// ═══════════════════════════════════════════════════════════════
-// VERIFICAR GREPAI
-// ═══════════════════════════════════════════════════════════════
-
-function isGrepaiAvailable(): boolean {
-  try {
-    const result = spawnSync("grepai", ["--version"], { encoding: "utf-8" });
-    return result.status === 0;
-  } catch {
-    return false;
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// BUSCA SEMÂNTICA
-// ═══════════════════════════════════════════════════════════════
-
-function searchWithGrepai(query: string, topK: number = 10): GrepaiResult[] {
-  try {
-    const result = spawnSync(
-      "grepai",
-      ["search", query, "--top", topK.toString(), "--format", "json"],
-      { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
-    );
-
-    if (result.status !== 0) {
-      console.warn(`  [!] grepai search falhou: ${result.stderr}`);
-      return [];
-    }
-
-    const output = result.stdout.trim();
-    if (!output || output === "[]") return [];
-
-    return JSON.parse(output) as GrepaiResult[];
-  } catch (error: any) {
-    console.warn(`  [!] Erro no grepai: ${error.message}`);
-    return [];
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// ANÁLISE DE ARQUIVOS
-// ═══════════════════════════════════════════════════════════════
-
-interface FileAnalysis {
-  path: string;
-  imports: string[];
-  exports: string[];
-  hasDefaultExport: boolean;
-  hasNamedExports: boolean;
-  conventions: string[];
-  size: number;
-}
-
-function analyzeFile(filePath: string): FileAnalysis | null {
-  if (!existsSync(filePath)) return null;
-
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const lines = content.split("\n");
-
-    const imports: string[] = [];
-    const exports: string[] = [];
-    const conventions: string[] = [];
-
-    let hasDefaultExport = false;
-    let hasNamedExports = false;
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-
-      // Extrair imports
-      const importMatch = trimmed.match(/^import\s+.*\s+from\s+['"]([^'"]+)['"]/);
-      if (importMatch) {
-        imports.push(importMatch[1]);
-      }
-
-      // Extrair exports
-      if (trimmed.startsWith("export default")) {
-        hasDefaultExport = true;
-        exports.push("default");
-      } else if (trimmed.startsWith("export ")) {
-        hasNamedExports = true;
-        const exportMatch = trimmed.match(/export\s+(?:const|function|class|interface|type)\s+(\w+)/);
-        if (exportMatch) {
-          exports.push(exportMatch[1]);
-        }
-      }
-
-      // Detectar convenções
-      if (trimmed.includes("'use client'") || trimmed.includes('"use client"')) {
-        conventions.push("use client");
-      }
-      if (trimmed.includes("'use server'") || trimmed.includes('"use server"')) {
-        conventions.push("use server");
-      }
-      if (trimmed.includes("async function") || trimmed.includes("async (")) {
-        conventions.push("async");
-      }
-    }
-
-    return {
-      path: filePath,
-      imports: [...new Set(imports)],
-      exports: [...new Set(exports)],
-      hasDefaultExport,
-      hasNamedExports,
-      conventions: [...new Set(conventions)],
-      size: content.length,
-    };
-  } catch {
-    return null;
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// v8.5: EXTRAÇÃO DE UTILITIES (DRY enforcement)
-// ═══════════════════════════════════════════════════════════════
-
-export interface ExtractedUtility {
-  name: string;
-  type: "function" | "const" | "class" | "interface" | "type";
-  signature?: string;
-}
-
-export function extractUtilitiesFromFile(filePath: string): ExtractedUtility[] {
-  if (!existsSync(filePath)) return [];
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const lines = content.split("\n");
-    const utilities: ExtractedUtility[] = [];
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-
-      // export [async] function name(args): ReturnType
-      const funcMatch = trimmed.match(
-        /^export\s+(?:async\s+)?function\s+(\w+)\s*(\([^)]*\)(?:\s*:\s*[^{]+)?)?/
-      );
-      if (funcMatch) {
-        utilities.push({
-          name: funcMatch[1],
-          type: "function",
-          signature: funcMatch[2]?.trim() || undefined,
-        });
-        continue;
-      }
-
-      // export const name: Type = ...
-      const constMatch = trimmed.match(
-        /^export\s+const\s+(\w+)(?:\s*:\s*([^=]+))?\s*=/
-      );
-      if (constMatch) {
-        utilities.push({
-          name: constMatch[1],
-          type: "const",
-          signature: constMatch[2]?.trim() || undefined,
-        });
-        continue;
-      }
-
-      // export class Name
-      const classMatch = trimmed.match(/^export\s+class\s+(\w+)/);
-      if (classMatch) {
-        utilities.push({ name: classMatch[1], type: "class" });
-        continue;
-      }
-
-      // export interface Name
-      const ifaceMatch = trimmed.match(/^export\s+interface\s+(\w+)/);
-      if (ifaceMatch) {
-        utilities.push({ name: ifaceMatch[1], type: "interface" });
-        continue;
-      }
-
-      // export type Name
-      const typeMatch = trimmed.match(/^export\s+type\s+(\w+)/);
-      if (typeMatch) {
-        utilities.push({ name: typeMatch[1], type: "type" });
-        continue;
-      }
-    }
-    return utilities;
-  } catch {
-    return [];
-  }
-}
-
-export function inferScopeFromPath(filePath: string): string {
-  const lower = filePath.toLowerCase().replace(/\\/g, "/");
-  if (lower.includes("/app/api/") || lower.includes("/server/") ||
-      lower.includes("/backend/") || lower.includes("/services/") ||
-      lower.includes("/actions/")) return "backend";
-  if (lower.includes("/components/") || lower.includes("/hooks/") ||
-      lower.includes("/pages/") || lower.includes("/frontend/")) return "frontend";
-  if (lower.includes("/app/") && !lower.includes("/api/")) return "frontend";
-  if (lower.includes("/db/") || lower.includes("/schema/") ||
-      lower.includes("/migration") || lower.includes("/database/")) return "database";
-  if (lower.includes("/test") || lower.includes(".test.") ||
-      lower.includes(".spec.")) return "testing";
-  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 hasUseClient = analyses.some((a) => a.conventions.includes("use client"));
-  const hasUseServer = analyses.some((a) => a.conventions.includes("use server"));
-  const hasAsync = analyses.some((a) => a.conventions.includes("async"));
-
-  let template = "";
-
-  // Diretiva de cliente/servidor
-  if (hasUseClient) {
-    template += `"use client"\n\n`;
-  } else if (hasUseServer) {
-    template += `"use server"\n\n`;
-  }
-
-  // Imports comuns
-  if (commonImports.length > 0) {
-    for (const imp of commonImports.slice(0, 5)) {
-      // Max 5 imports
-      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
-  switch (category) {
-    case "component":
-      template += `interface {{ComponentName}}Props {\n  // Props\n}\n\n`;
-      template += hasAsync
-        ? `export default async function {{ComponentName}}({ /* props */ }: {{ComponentName}}Props) {\n  // Implementação\n  return (\n    <div>\n      {/* JSX */}\n    </div>\n  )\n}`
-        : `export default function {{ComponentName}}({ /* props */ }: {{ComponentName}}Props) {\n  // Implementação\n  return (\n    <div>\n      {/* JSX */}\n    </div>\n  )\n}`;
-      break;
-
-    case "hook":
-      template += `export function use{{HookName}}() {\n  // Estado e lógica\n  \n  return {\n    // Valores e funções\n  }\n}`;
-      break;
-
-    case "route":
-      template += `import { NextRequest, NextResponse } from "next/server"\n\n`;
-      template += `export async function GET(request: NextRequest) {\n  // Implementação GET\n  return NextResponse.json({ /* data */ })\n}\n\n`;
-      template += `export async function POST(request: NextRequest) {\n  // Implementação POST\n  return NextResponse.json({ /* data */ })\n}`;
-      break;
-
-    case "service":
-      template += `export class {{ServiceName}}Service {\n  constructor() {\n    // Inicialização\n  }\n\n  async execute() {\n    // Lógica do serviço\n  }\n}`;
-      break;
-
-    case "action":
-      template += `"use server"\n\n`;
-      template += `export async function {{actionName}}(formData: FormData) {\n  // Validação\n  \n  // Lógica\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})`;
-      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;
-
-    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));
-
-  // Gerar template
-  const template = generateTemplate(analyses, query.category);
-
-  // Calcular confiança baseada em quantos arquivos seguem o pattern
-  const confidence = Math.min(analyses.length / 10, 1); // Max 1.0 com 10+ arquivos
-
-  // Gerar nome único
-  const name = `${query.scope}-${query.category}-pattern`;
-
-  return {
-    category: query.category,
-    name: name,
-    scope: query.scope,
-    appliesTo: query.appliesTo,
-    structure: {
-      commonImports,
-      commonExports,
-      conventions: commonConventions,
-    },
-    template,
-    examples: files.slice(0, 5).map((f) => ({
-      path: f.path,
-      relevance: f.score || 0.8,
-    })),
-    antiPatterns: [], // Será preenchido se detectarmos inconsistências
-    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()) {
-    console.error("\n[ERRO] grepai nao encontrado.");
-    console.error("Instale com: go install github.com/your-org/grepai@latest");
-    console.error("Ou configure no PATH.\n");
-    process.exit(1);
-  }
-
-  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) {
-    console.error(`\n[ERRO] Escopo '${options.scope}' nao reconhecido.`);
-    console.error("Escopos validos: frontend, backend, database, testing\n");
-    process.exit(1);
-  }
-
-  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)) {
-    console.error(`\n[ERRO] Arquivo nao encontrado: ${filePath}\n`);
-    process.exit(1);
-  }
-
-  const analysis = analyzeFile(filePath);
-
-  if (!analysis) {
-    console.error(`\n[ERRO] Nao foi possivel analisar o arquivo.\n`);
-    process.exit(1);
-  }
-
-  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(`\nConvenções:`);
-  console.log(`  - Default export: ${analysis.hasDefaultExport ? "sim" : "não"}`);
-  console.log(`  - Named exports: ${analysis.hasNamedExports ? "sim" : "não"}`);
-  if (analysis.conventions.length > 0) {
-    console.log(`  - Diretivas: ${analysis.conventions.join(", ")}`);
-  }
-  console.log(`\nTamanho: ${analysis.size} bytes\n`);
-}
+/**
+ * Codexa Workflow v8.0 - Extração Automática de Patterns via Grepai
+ *
+ * Usa busca semântica (grepai search) para encontrar arquivos por intenção
+ * e extrair patterns de código automaticamente.
+ */
+
+import { execSync, spawnSync } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { extname, basename, dirname } from "path";
+import { getDb } from "../db/connection";
+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[];
+  };
+  template: string;
+  examples: Array<{ path: string; relevance: number }>;
+  antiPatterns: string[];
+  confidence: number;
+  extractedFrom: number;
+}
+
+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" },
+];
+
+// ═══════════════════════════════════════════════════════════════
+// VERIFICAR GREPAI
+// ═══════════════════════════════════════════════════════════════
+
+function isGrepaiAvailable(): boolean {
+  try {
+    const result = spawnSync("grepai", ["--version"], { encoding: "utf-8" });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// BUSCA SEMÂNTICA
+// ═══════════════════════════════════════════════════════════════
+
+function searchWithGrepai(query: string, topK: number = 10): GrepaiResult[] {
+  try {
+    const result = spawnSync(
+      "grepai",
+      ["search", query, "--top", topK.toString(), "--format", "json"],
+      { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+    );
+
+    if (result.status !== 0) {
+      console.warn(`  [!] grepai search falhou: ${result.stderr}`);
+      return [];
+    }
+
+    const output = result.stdout.trim();
+    if (!output || output === "[]") return [];
+
+    return JSON.parse(output) as GrepaiResult[];
+  } catch (error: any) {
+    console.warn(`  [!] Erro no grepai: ${error.message}`);
+    return [];
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// ANÁLISE DE ARQUIVOS
+// ═══════════════════════════════════════════════════════════════
+
+interface FileAnalysis {
+  path: string;
+  imports: string[];
+  exports: string[];
+  hasDefaultExport: boolean;
+  hasNamedExports: boolean;
+  conventions: string[];
+  size: number;
+}
+
+function analyzeFile(filePath: string): FileAnalysis | null {
+  if (!existsSync(filePath)) return null;
+
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+
+    const imports: string[] = [];
+    const exports: string[] = [];
+    const conventions: string[] = [];
+
+    let hasDefaultExport = false;
+    let hasNamedExports = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Extrair imports
+      const importMatch = trimmed.match(/^import\s+.*\s+from\s+['"]([^'"]+)['"]/);
+      if (importMatch) {
+        imports.push(importMatch[1]);
+      }
+
+      // Extrair exports
+      if (trimmed.startsWith("export default")) {
+        hasDefaultExport = true;
+        exports.push("default");
+      } else if (trimmed.startsWith("export ")) {
+        hasNamedExports = true;
+        const exportMatch = trimmed.match(/export\s+(?:const|function|class|interface|type)\s+(\w+)/);
+        if (exportMatch) {
+          exports.push(exportMatch[1]);
+        }
+      }
+
+      // Detectar convenções
+      if (trimmed.includes("'use client'") || trimmed.includes('"use client"')) {
+        conventions.push("use client");
+      }
+      if (trimmed.includes("'use server'") || trimmed.includes('"use server"')) {
+        conventions.push("use server");
+      }
+      if (trimmed.includes("async function") || trimmed.includes("async (")) {
+        conventions.push("async");
+      }
+    }
+
+    return {
+      path: filePath,
+      imports: [...new Set(imports)],
+      exports: [...new Set(exports)],
+      hasDefaultExport,
+      hasNamedExports,
+      conventions: [...new Set(conventions)],
+      size: content.length,
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// v8.5: EXTRAÇÃO DE UTILITIES (DRY enforcement)
+// ═══════════════════════════════════════════════════════════════
+
+export interface ExtractedUtility {
+  name: string;
+  type: "function" | "const" | "class" | "interface" | "type";
+  signature?: string;
+}
+
+export function extractUtilitiesFromFile(filePath: string): ExtractedUtility[] {
+  if (!existsSync(filePath)) return [];
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const utilities: ExtractedUtility[] = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // export [async] function name(args): ReturnType
+      const funcMatch = trimmed.match(
+        /^export\s+(?:async\s+)?function\s+(\w+)\s*(\([^)]*\)(?:\s*:\s*[^{]+)?)?/
+      );
+      if (funcMatch) {
+        utilities.push({
+          name: funcMatch[1],
+          type: "function",
+          signature: funcMatch[2]?.trim() || undefined,
+        });
+        continue;
+      }
+
+      // export const name: Type = ...
+      const constMatch = trimmed.match(
+        /^export\s+const\s+(\w+)(?:\s*:\s*([^=]+))?\s*=/
+      );
+      if (constMatch) {
+        utilities.push({
+          name: constMatch[1],
+          type: "const",
+          signature: constMatch[2]?.trim() || undefined,
+        });
+        continue;
+      }
+
+      // export class Name
+      const classMatch = trimmed.match(/^export\s+class\s+(\w+)/);
+      if (classMatch) {
+        utilities.push({ name: classMatch[1], type: "class" });
+        continue;
+      }
+
+      // export interface Name
+      const ifaceMatch = trimmed.match(/^export\s+interface\s+(\w+)/);
+      if (ifaceMatch) {
+        utilities.push({ name: ifaceMatch[1], type: "interface" });
+        continue;
+      }
+
+      // export type Name
+      const typeMatch = trimmed.match(/^export\s+type\s+(\w+)/);
+      if (typeMatch) {
+        utilities.push({ name: typeMatch[1], type: "type" });
+        continue;
+      }
+    }
+    return utilities;
+  } catch {
+    return [];
+  }
+}
+
+export function inferScopeFromPath(filePath: string): string {
+  const lower = filePath.toLowerCase().replace(/\\/g, "/");
+  if (lower.includes("/app/api/") || lower.includes("/server/") ||
+      lower.includes("/backend/") || lower.includes("/services/") ||
+      lower.includes("/actions/")) return "backend";
+  if (lower.includes("/components/") || lower.includes("/hooks/") ||
+      lower.includes("/pages/") || lower.includes("/frontend/")) return "frontend";
+  if (lower.includes("/app/") && !lower.includes("/api/")) return "frontend";
+  if (lower.includes("/db/") || lower.includes("/schema/") ||
+      lower.includes("/migration") || lower.includes("/database/")) return "database";
+  if (lower.includes("/test") || lower.includes(".test.") ||
+      lower.includes(".spec.")) return "testing";
+  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 hasUseClient = analyses.some((a) => a.conventions.includes("use client"));
+  const hasUseServer = analyses.some((a) => a.conventions.includes("use server"));
+  const hasAsync = analyses.some((a) => a.conventions.includes("async"));
+
+  let template = "";
+
+  // Diretiva de cliente/servidor
+  if (hasUseClient) {
+    template += `"use client"\n\n`;
+  } else if (hasUseServer) {
+    template += `"use server"\n\n`;
+  }
+
+  // Imports comuns
+  if (commonImports.length > 0) {
+    for (const imp of commonImports.slice(0, 5)) {
+      // Max 5 imports
+      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
+  switch (category) {
+    case "component":
+      template += `interface {{ComponentName}}Props {\n  // Props\n}\n\n`;
+      template += hasAsync
+        ? `export default async function {{ComponentName}}({ /* props */ }: {{ComponentName}}Props) {\n  // Implementação\n  return (\n    <div>\n      {/* JSX */}\n    </div>\n  )\n}`
+        : `export default function {{ComponentName}}({ /* props */ }: {{ComponentName}}Props) {\n  // Implementação\n  return (\n    <div>\n      {/* JSX */}\n    </div>\n  )\n}`;
+      break;
+
+    case "hook":
+      template += `export function use{{HookName}}() {\n  // Estado e lógica\n  \n  return {\n    // Valores e funções\n  }\n}`;
+      break;
+
+    case "route":
+      template += `import { NextRequest, NextResponse } from "next/server"\n\n`;
+      template += `export async function GET(request: NextRequest) {\n  // Implementação GET\n  return NextResponse.json({ /* data */ })\n}\n\n`;
+      template += `export async function POST(request: NextRequest) {\n  // Implementação POST\n  return NextResponse.json({ /* data */ })\n}`;
+      break;
+
+    case "service":
+      template += `export class {{ServiceName}}Service {\n  constructor() {\n    // Inicialização\n  }\n\n  async execute() {\n    // Lógica do serviço\n  }\n}`;
+      break;
+
+    case "action":
+      template += `"use server"\n\n`;
+      template += `export async function {{actionName}}(formData: FormData) {\n  // Validação\n  \n  // Lógica\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})`;
+      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;
+
+    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));
+
+  // Gerar template
+  const template = generateTemplate(analyses, query.category);
+
+  // Calcular confiança baseada em quantos arquivos seguem o pattern
+  const confidence = Math.min(analyses.length / 10, 1); // Max 1.0 com 10+ arquivos
+
+  // Gerar nome único
+  const name = `${query.scope}-${query.category}-pattern`;
+
+  return {
+    category: query.category,
+    name: name,
+    scope: query.scope,
+    appliesTo: query.appliesTo,
+    structure: {
+      commonImports,
+      commonExports,
+      conventions: commonConventions,
+    },
+    template,
+    examples: files.slice(0, 5).map((f) => ({
+      path: f.path,
+      relevance: f.score || 0.8,
+    })),
+    antiPatterns: [], // Será preenchido se detectarmos inconsistências
+    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()) {
+    console.error("\n[ERRO] grepai nao encontrado.");
+    console.error("Instale com: go install github.com/your-org/grepai@latest");
+    console.error("Ou configure no PATH.\n");
+    process.exit(1);
+  }
+
+  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) {
+    console.error(`\n[ERRO] Escopo '${options.scope}' nao reconhecido.`);
+    console.error("Escopos validos: frontend, backend, database, testing\n");
+    process.exit(1);
+  }
+
+  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)) {
+    console.error(`\n[ERRO] Arquivo nao encontrado: ${filePath}\n`);
+    process.exit(1);
+  }
+
+  const analysis = analyzeFile(filePath);
+
+  if (!analysis) {
+    console.error(`\n[ERRO] Nao foi possivel analisar o arquivo.\n`);
+    process.exit(1);
+  }
+
+  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(`\nConvenções:`);
+  console.log(`  - Default export: ${analysis.hasDefaultExport ? "sim" : "não"}`);
+  console.log(`  - Named exports: ${analysis.hasNamedExports ? "sim" : "não"}`);
+  if (analysis.conventions.length > 0) {
+    console.log(`  - Diretivas: ${analysis.conventions.join(", ")}`);
+  }
+  console.log(`\nTamanho: ${analysis.size} bytes\n`);
+}