@codexa/cli 8.5.0

package/commands/discover.ts

@@ -0,0 +1,1000 @@
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import {
+  detectUniversal,
+  detectStackLegacy,
+  formatDetectionResult,
+  getDetailedTechnologies,
+  type UnifiedDetectionResult,
+} from "../detectors/loader";
+
+interface StackDetection {
+  frontend?: string;
+  backend?: string;
+  database?: string;
+  orm?: string;
+  styling?: string;
+  auth?: string;
+  testing?: string;
+}
+
+interface StructureDetection {
+  components?: string;
+  services?: string;
+  schema?: string;
+  types?: string;
+  hooks?: string;
+  utils?: string;
+  api?: string;
+}
+
+// Store last detection result for extended info
+let lastDetectionResult: UnifiedDetectionResult | null = null;
+
+/**
+ * Universal stack detection using the new modular detector system.
+ * Supports: Node.js, .NET, Python, Go, Rust, Java/Kotlin, Flutter, and more.
+ */
+async function detectStack(): Promise<StackDetection> {
+  const result = await detectStackLegacy(process.cwd());
+  return result.stack;
+}
+
+/**
+ * Structure detection using the new modular detector system.
+ */
+async function detectStructure(): Promise<StructureDetection> {
+  const result = await detectStackLegacy(process.cwd());
+
+  // Map new structure keys to legacy format
+  const structure: StructureDetection = {};
+
+  if (result.structure.components) structure.components = result.structure.components;
+  if (result.structure.services) structure.services = result.structure.services;
+  if (result.structure.schema) structure.schema = result.structure.schema;
+  if (result.structure.types) structure.types = result.structure.types;
+  if (result.structure.hooks) structure.hooks = result.structure.hooks;
+  if (result.structure.utils) structure.utils = result.structure.utils;
+  if (result.structure.api) structure.api = result.structure.api;
+
+  return structure;
+}
+
+/**
+ * Full detection with all details (for extended display)
+ */
+async function detectFull(): Promise<UnifiedDetectionResult> {
+  const result = await detectUniversal(process.cwd());
+  lastDetectionResult = result;
+  return result;
+}
+
+export async function discoverStart(json: boolean = false): Promise<void> {
+  initSchema();
+  const db = getDb();
+
+  // Verificar se ja foi descoberto
+  const existing = db.query("SELECT * FROM project WHERE id = 'default'").get();
+  if (existing) {
+    console.log("\nProjeto ja foi descoberto.");
+    console.log("Use: discover show para ver detalhes");
+    console.log("Ou: discover reset para refazer\n");
+    return;
+  }
+
+  console.log("\nIniciando descoberta do projeto...\n");
+
+  if (!json) {
+    console.log("[1/2] Detectando stack tecnológico (universal)...");
+  }
+
+  // Usar novo sistema de detecção universal
+  const fullResult = await detectFull();
+
+  // Converter para formato legacy para compatibilidade
+  const stack = await detectStack();
+  const structure = await detectStructure();
+
+  if (!json) {
+    console.log(`    ✓ ${fullResult.ecosystems.length > 0 ? fullResult.ecosystems.join(", ") : "Stack"} detectado\n`);
+    console.log("[2/2] Analisando estrutura de diretórios...");
+    console.log("    ✓ Estrutura mapeada\n");
+  }
+
+  if (json) {
+    console.log(JSON.stringify({
+      stack,
+      structure,
+      // Extended info from new detection system
+      extended: {
+        primary: fullResult.primary,
+        ecosystems: fullResult.ecosystems,
+        technologies: getDetailedTechnologies(fullResult),
+        configFiles: fullResult.configFiles,
+        fullStructure: fullResult.structure,
+      }
+    }, null, 2));
+    return;
+  }
+
+  // Use new formatted output
+  console.log(formatDetectionResult(fullResult));
+
+  // Show legacy structure format as well for compatibility
+  console.log("\n" + "═".repeat(60));
+  console.log("ESTRUTURA DETECTADA (Legacy)");
+  console.log("═".repeat(60));
+
+  if (Object.keys(structure).length === 0) {
+    console.log("\nNenhuma estrutura padrao detectada.");
+  } else {
+    console.log();
+    if (structure.components) console.log(`  Componentes: ${structure.components}/`);
+    if (structure.services) console.log(`  Services: ${structure.services}/`);
+    if (structure.schema) console.log(`  Schema DB: ${structure.schema}/`);
+    if (structure.types) console.log(`  Tipos: ${structure.types}/`);
+    if (structure.hooks) console.log(`  Hooks: ${structure.hooks}/`);
+    if (structure.utils) console.log(`  Utils: ${structure.utils}/`);
+    if (structure.api) console.log(`  API: ${structure.api}/`);
+  }
+
+  console.log("\n" + "─".repeat(60));
+  console.log("\nPara confirmar e salvar: discover confirm");
+  console.log("Para ajustar stack: discover set-stack --frontend next --backend bun");
+  console.log("Para ajustar estrutura: discover set-structure --components src/ui\n");
+
+  // Salvar temporariamente para confirm poder usar
+  // Include extended info for richer context
+  db.run(
+    `INSERT OR REPLACE INTO project (id, name, stack, discovered_at, updated_at)
+     VALUES ('pending', 'pending', ?, datetime('now'), datetime('now'))`,
+    [JSON.stringify({
+      stack,
+      structure,
+      extended: {
+        primary: fullResult.primary,
+        ecosystems: fullResult.ecosystems,
+        allTechnologies: fullResult.allTechnologies,
+        configFiles: fullResult.configFiles,
+        fullStructure: fullResult.structure,
+      }
+    })]
+  );
+}
+
+export function discoverConfirm(): void {
+  initSchema();
+  const db = getDb();
+
+  const pending = db.query("SELECT * FROM project WHERE id = 'pending'").get() as any;
+  if (!pending) {
+    console.error("\nNenhuma descoberta pendente.");
+    console.error("Execute: discover start primeiro\n");
+    process.exit(1);
+  }
+
+  const data = JSON.parse(pending.stack);
+  const now = new Date().toISOString();
+
+  // 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]
+  );
+
+  // Criar standards baseados na estrutura detectada
+  const structure = data.structure as StructureDetection;
+
+  if (structure.components) {
+    db.run(
+      `INSERT INTO standards (category, scope, rule, examples, source, created_at)
+       VALUES ('structure', 'frontend', ?, ?, 'detected', ?)`,
+      [
+        `Componentes devem estar em ${structure.components}/`,
+        JSON.stringify([`${structure.components}/Button.tsx`]),
+        now,
+      ]
+    );
+  }
+
+  if (structure.services) {
+    db.run(
+      `INSERT INTO standards (category, scope, rule, examples, source, created_at)
+       VALUES ('structure', 'backend', ?, ?, 'detected', ?)`,
+      [
+        `Services devem estar em ${structure.services}/`,
+        JSON.stringify([`${structure.services}/authService.ts`]),
+        now,
+      ]
+    );
+  }
+
+  if (structure.schema) {
+    db.run(
+      `INSERT INTO standards (category, scope, rule, examples, source, created_at)
+       VALUES ('structure', 'database', ?, ?, 'detected', ?)`,
+      [
+        `Schema do banco deve estar em ${structure.schema}/`,
+        JSON.stringify([`${structure.schema}/users.ts`]),
+        now,
+      ]
+    );
+  }
+
+  if (structure.types) {
+    db.run(
+      `INSERT INTO standards (category, scope, rule, examples, source, created_at)
+       VALUES ('structure', 'all', ?, ?, 'detected', ?)`,
+      [
+        `Tipos devem estar em ${structure.types}/`,
+        JSON.stringify([`${structure.types}/user.ts`]),
+        now,
+      ]
+    );
+  }
+
+  // Standards de nomenclatura padrao
+  db.run(
+    `INSERT INTO standards (category, scope, rule, examples, anti_examples, source, created_at)
+     VALUES ('naming', 'frontend', ?, ?, ?, 'detected', ?)`,
+    [
+      "Componentes usam PascalCase",
+      JSON.stringify(["Button.tsx", "LoginForm.tsx"]),
+      JSON.stringify(["button.tsx", "login-form.tsx"]),
+      now,
+    ]
+  );
+
+  db.run(
+    `INSERT INTO standards (category, scope, rule, examples, anti_examples, source, created_at)
+     VALUES ('naming', 'backend', ?, ?, ?, 'detected', ?)`,
+    [
+      "Services usam camelCase",
+      JSON.stringify(["authService.ts", "userService.ts"]),
+      JSON.stringify(["AuthService.ts", "auth-service.ts"]),
+      now,
+    ]
+  );
+
+  // Gerar arquivo standards.md
+  generateStandardsMarkdown();
+
+  const standardsCount = db.query("SELECT COUNT(*) as c FROM standards").get() as any;
+
+  console.log("\nProjeto descoberto e configurado!");
+  console.log(`Standards criados: ${standardsCount.c}`);
+  console.log("\nArquivo gerado: .codexa/standards.md");
+  console.log("\nProximo passo: /codexa:feature para iniciar uma feature\n");
+}
+
+export function discoverShow(json: boolean = false): void {
+  initSchema();
+  const db = getDb();
+
+  const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
+
+  if (!project) {
+    console.error("\nProjeto nao descoberto.");
+    console.error("Execute: discover start\n");
+    process.exit(1);
+  }
+
+  const standards = db.query("SELECT * FROM standards ORDER BY category, scope").all() as any[];
+  const stack = JSON.parse(project.stack);
+
+  if (json) {
+    console.log(JSON.stringify({ project, stack, standards }, null, 2));
+    return;
+  }
+
+  console.log("\n" + "═".repeat(60));
+  console.log("PROJETO CONFIGURADO");
+  console.log("═".repeat(60));
+
+  console.log("\nStack:");
+  for (const [key, value] of Object.entries(stack)) {
+    if (value) console.log(`  ${key}: ${value}`);
+  }
+
+  console.log(`\nStandards (${standards.length}):`);
+  console.log("─".repeat(60));
+
+  let currentCategory = "";
+  for (const std of standards) {
+    if (std.category !== currentCategory) {
+      currentCategory = std.category;
+      console.log(`\n[${currentCategory.toUpperCase()}]`);
+    }
+    console.log(`  (${std.scope}) ${std.rule}`);
+  }
+
+  console.log("\n" + "─".repeat(60));
+  console.log("Arquivo: .codexa/standards.md\n");
+}
+
+export function discoverSetStack(options: {
+  frontend?: string;
+  backend?: string;
+  database?: string;
+  orm?: string;
+  styling?: string;
+  auth?: string;
+  testing?: string;
+}): void {
+  initSchema();
+  const db = getDb();
+
+  let pending = db.query("SELECT * FROM project WHERE id = 'pending'").get() as any;
+  let data: any;
+
+  if (pending) {
+    data = JSON.parse(pending.stack);
+  } else {
+    data = { stack: {}, structure: {} };
+  }
+
+  // Atualizar stack com opcoes fornecidas
+  if (options.frontend) data.stack.frontend = options.frontend;
+  if (options.backend) data.stack.backend = options.backend;
+  if (options.database) data.stack.database = options.database;
+  if (options.orm) data.stack.orm = options.orm;
+  if (options.styling) data.stack.styling = options.styling;
+  if (options.auth) data.stack.auth = options.auth;
+  if (options.testing) data.stack.testing = options.testing;
+
+  db.run(
+    `INSERT OR REPLACE INTO project (id, name, stack, discovered_at, updated_at)
+     VALUES ('pending', 'pending', ?, datetime('now'), datetime('now'))`,
+    [JSON.stringify(data)]
+  );
+
+  console.log("\nStack atualizado:");
+  for (const [key, value] of Object.entries(data.stack)) {
+    if (value) console.log(`  ${key}: ${value}`);
+  }
+  console.log("\nPara confirmar: discover confirm\n");
+}
+
+export function discoverReset(): void {
+  initSchema();
+  const db = getDb();
+
+  db.run("DELETE FROM project");
+  db.run("DELETE FROM standards");
+
+  console.log("\nDescoberta resetada.");
+  console.log("Execute: discover start para refazer\n");
+}
+
+export async function discoverRefresh(options: { force?: boolean } = {}): Promise<void> {
+  initSchema();
+  const db = getDb();
+
+  const currentProject = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
+  if (!currentProject) {
+    console.error("\nProjeto nao descoberto.");
+    console.error("Execute: discover start primeiro\n");
+    process.exit(1);
+  }
+
+  const currentStack = JSON.parse(currentProject.stack);
+  const newStack = await detectStack();
+  const newStructure = await detectStructure();
+
+  // Comparar stacks
+  const stackChanges: { key: string; from: string | undefined; to: string | undefined }[] = [];
+  const allKeys = new Set([...Object.keys(currentStack), ...Object.keys(newStack)]);
+
+  for (const key of allKeys) {
+    const current = currentStack[key as keyof StackDetection];
+    const detected = newStack[key as keyof StackDetection];
+    if (current !== detected) {
+      stackChanges.push({ key, from: current, to: detected });
+    }
+  }
+
+  if (stackChanges.length === 0) {
+    console.log("\n✓ Stack continua o mesmo. Nenhuma mudanca detectada.\n");
+    return;
+  }
+
+  console.log("\n" + "═".repeat(60));
+  console.log("MUDANCAS DETECTADAS NO STACK");
+  console.log("═".repeat(60) + "\n");
+
+  for (const change of stackChanges) {
+    const from = change.from || "(nao definido)";
+    const to = change.to || "(removido)";
+    console.log(`  ${change.key}: ${from} → ${to}`);
+  }
+
+  if (options.force) {
+    // Aplicar mudanças
+    const now = new Date().toISOString();
+
+    db.run(
+      `UPDATE project SET stack = ?, updated_at = ? WHERE id = 'default'`,
+      [JSON.stringify(newStack), now]
+    );
+
+    // Atualizar standards de stack
+    for (const change of stackChanges) {
+      if (change.to) {
+        // Adicionar ou atualizar standard de stack
+        const existing = db.query(
+          `SELECT id FROM standards WHERE category = 'stack' AND rule LIKE ?`
+        ).get(`%${change.key}%`) as any;
+
+        if (existing) {
+          db.run(
+            `UPDATE standards SET rule = ?, updated_at = ? WHERE id = ?`,
+            [`${change.key}: ${change.to}`, now, existing.id]
+          );
+        } else {
+          db.run(
+            `INSERT INTO standards (category, scope, rule, enforcement, source, created_at)
+             VALUES ('stack', 'all', ?, 'required', 'refresh', ?)`,
+            [`${change.key}: ${change.to}`, now]
+          );
+        }
+      }
+    }
+
+    // Regenerar standards.md
+    generateStandardsMarkdown();
+
+    console.log("\n✓ Stack atualizado com sucesso!");
+    console.log("✓ Standards regenerados\n");
+  } else {
+    console.log("\n" + "─".repeat(60));
+    console.log("Para aplicar as mudancas: discover refresh --force\n");
+  }
+}
+
+// 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;
+  const standards = db.query("SELECT * FROM standards ORDER BY category, scope").all() as any[];
+
+  if (!project) return;
+
+  const stack = JSON.parse(project.stack);
+  let md = `# Standards do Projeto
+
+> Gerado automaticamente do SQLite. Nao edite manualmente.
+> Para modificar, use os comandos CLI.
+> Gerado em: ${new Date().toISOString()}
+
+## Stack
+
+`;
+
+  for (const [key, value] of Object.entries(stack)) {
+    if (value) md += `- **${key}:** ${value}\n`;
+  }
+
+  // Agrupar standards por categoria
+  const byCategory: Record<string, any[]> = {};
+  for (const std of standards) {
+    if (!byCategory[std.category]) byCategory[std.category] = [];
+    byCategory[std.category].push(std);
+  }
+
+  for (const [category, stds] of Object.entries(byCategory)) {
+    md += `\n## ${category.charAt(0).toUpperCase() + category.slice(1)}\n\n`;
+
+    for (const std of stds) {
+      const enforcement = std.enforcement === "required" ? "OBRIGATORIO" : "Recomendado";
+      md += `### ${std.rule}\n\n`;
+      md += `- **Escopo:** ${std.scope}\n`;
+      md += `- **Enforcement:** ${enforcement}\n`;
+
+      if (std.examples) {
+        const examples = JSON.parse(std.examples);
+        md += `- **Exemplos:**\n`;
+        for (const ex of examples) {
+          md += `  - \`${ex}\`\n`;
+        }
+      }
+
+      if (std.anti_examples) {
+        const antiExamples = JSON.parse(std.anti_examples);
+        md += `- **Nao fazer:**\n`;
+        for (const ex of antiExamples) {
+          md += `  - ~~\`${ex}\`~~\n`;
+        }
+      }
+
+      md += "\n";
+    }
+  }
+
+  // Garantir que diretorio existe
+  const mdPath = join(process.cwd(), ".codexa", "standards.md");
+  writeFileSync(mdPath, md);
+}
+
+export { generateStandardsMarkdown };
+
+// ============================================================
+// PATTERN EXTRACTION (v7.4)
+// ============================================================
+
+interface PatternStructure {
+  imports: {
+    order: string[];
+    common: string[];
+    conditional: string[];
+  };
+  exports: {
+    style: "named" | "default" | "both";
+    async: boolean;
+  };
+  patterns: {
+    hooks_used: string[];
+    props_style: "interface" | "type" | "inline";
+    error_handling: string;
+    data_fetching: string;
+  };
+  conventions: {
+    file_structure: string[];
+    naming: {
+      functions: string;
+      variables: string;
+      types: string;
+    };
+  };
+}
+
+interface AntiPattern {
+  description: string;
+  example: string;
+  found_in: string[];
+  recommendation?: string;
+}
+
+interface ImplementationPattern {
+  category: string;
+  name: string;
+  scope: string;
+  applies_to: string;
+  structure: PatternStructure;
+  template: string;
+  examples: { path: string; relevance: number }[];
+  anti_patterns: AntiPattern[];
+  confidence: number;
+  extracted_from: number;
+}
+
+export function discoverPatterns(options: { category?: string; json?: boolean } = {}): void {
+  initSchema();
+  const db = getDb();
+
+  let query = "SELECT * FROM implementation_patterns";
+  const params: string[] = [];
+
+  if (options.category) {
+    query += " WHERE category = ?";
+    params.push(options.category);
+  }
+
+  query += " ORDER BY category, name";
+
+  const patterns = db.query(query).all(...params) as any[];
+
+  if (patterns.length === 0) {
+    console.log("\nNenhum pattern extraido ainda.");
+    console.log("Execute: discover start para extrair patterns do codigo\n");
+    return;
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(patterns.map(p => ({
+      ...p,
+      structure: JSON.parse(p.structure || "{}"),
+      examples: JSON.parse(p.examples || "[]"),
+      anti_patterns: JSON.parse(p.anti_patterns || "[]"),
+    })), null, 2));
+    return;
+  }
+
+  console.log("\n" + "═".repeat(70));
+  console.log("IMPLEMENTATION PATTERNS EXTRAIDOS");
+  console.log("═".repeat(70) + "\n");
+
+  console.log("┌" + "─".repeat(20) + "┬" + "─".repeat(25) + "┬" + "─".repeat(10) + "┬" + "─".repeat(10) + "┐");
+  console.log("│ Categoria          │ Nome                    │ Arquivos │ Confianca│");
+  console.log("├" + "─".repeat(20) + "┼" + "─".repeat(25) + "┼" + "─".repeat(10) + "┼" + "─".repeat(10) + "┤");
+
+  for (const p of patterns) {
+    const cat = p.category.padEnd(18);
+    const name = p.name.substring(0, 23).padEnd(23);
+    const files = String(p.extracted_from || 0).padStart(8);
+    const conf = ((p.confidence || 0) * 100).toFixed(0).padStart(7) + "%";
+    console.log(`│ ${cat} │ ${name} │ ${files} │ ${conf} │`);
+  }
+
+  console.log("└" + "─".repeat(20) + "┴" + "─".repeat(25) + "┴" + "─".repeat(10) + "┴" + "─".repeat(10) + "┘");
+
+  // Contar anti-patterns
+  let totalAntiPatterns = 0;
+  for (const p of patterns) {
+    const antiPatterns = JSON.parse(p.anti_patterns || "[]");
+    totalAntiPatterns += antiPatterns.length;
+  }
+
+  if (totalAntiPatterns > 0) {
+    console.log(`\n⚠ Anti-patterns identificados: ${totalAntiPatterns}`);
+    console.log("  Use: discover patterns --show <name> para ver detalhes");
+  }
+
+  console.log("\n" + "─".repeat(70));
+  console.log("Para ver detalhes: discover patterns --show <name>");
+  console.log("Para exportar: discover export-patterns\n");
+}
+
+export function discoverPatternsShow(name: string, json: boolean = false): void {
+  initSchema();
+  const db = getDb();
+
+  const pattern = db.query("SELECT * FROM implementation_patterns WHERE name = ?").get(name) as any;
+
+  if (!pattern) {
+    console.error(`\nPattern '${name}' nao encontrado.`);
+    console.error("Use: discover patterns para listar todos\n");
+    process.exit(1);
+  }
+
+  const structure = JSON.parse(pattern.structure || "{}");
+  const examples = JSON.parse(pattern.examples || "[]");
+  const antiPatterns = JSON.parse(pattern.anti_patterns || "[]");
+
+  if (json) {
+    console.log(JSON.stringify({
+      ...pattern,
+      structure,
+      examples,
+      anti_patterns: antiPatterns,
+    }, null, 2));
+    return;
+  }
+
+  console.log("\n" + "═".repeat(70));
+  console.log(`PATTERN: ${pattern.name}`);
+  console.log("═".repeat(70));
+
+  console.log(`\nCategoria: ${pattern.category}`);
+  console.log(`Escopo: ${pattern.scope}`);
+  console.log(`Aplica-se a: ${pattern.applies_to}`);
+  console.log(`Confianca: ${((pattern.confidence || 0) * 100).toFixed(0)}%`);
+  console.log(`Extraido de: ${pattern.extracted_from} arquivos`);
+
+  console.log("\n" + "─".repeat(70));
+  console.log("ESTRUTURA");
+  console.log("─".repeat(70));
+
+  if (structure.imports) {
+    console.log("\nImports:");
+    console.log(`  Ordem: ${structure.imports.order?.join(" → ") || "N/A"}`);
+    console.log(`  Comuns: ${structure.imports.common?.join(", ") || "N/A"}`);
+  }
+
+  if (structure.exports) {
+    console.log("\nExports:");
+    console.log(`  Estilo: ${structure.exports.style || "N/A"}`);
+    console.log(`  Async: ${structure.exports.async ? "Sim" : "Nao"}`);
+  }
+
+  if (structure.patterns) {
+    console.log("\nPadroes:");
+    console.log(`  Hooks: ${structure.patterns.hooks_used?.join(", ") || "N/A"}`);
+    console.log(`  Props: ${structure.patterns.props_style || "N/A"}`);
+    console.log(`  Erro: ${structure.patterns.error_handling || "N/A"}`);
+    console.log(`  Data: ${structure.patterns.data_fetching || "N/A"}`);
+  }
+
+  console.log("\n" + "─".repeat(70));
+  console.log("TEMPLATE");
+  console.log("─".repeat(70));
+  console.log("\n" + pattern.template);
+
+  console.log("\n" + "─".repeat(70));
+  console.log("EXEMPLOS DE REFERENCIA");
+  console.log("─".repeat(70));
+
+  for (const ex of examples.slice(0, 5)) {
+    const relevance = ((ex.relevance || 0) * 100).toFixed(0);
+    console.log(`  ${ex.path} (${relevance}% similar)`);
+  }
+
+  if (antiPatterns.length > 0) {
+    console.log("\n" + "─".repeat(70));
+    console.log("⚠ ANTI-PATTERNS IDENTIFICADOS");
+    console.log("─".repeat(70));
+
+    for (const ap of antiPatterns) {
+      console.log(`\n  ❌ ${ap.description}`);
+      console.log(`     Encontrado em: ${ap.found_in?.join(", ") || "N/A"}`);
+      if (ap.recommendation) {
+        console.log(`     Recomendacao: ${ap.recommendation}`);
+      }
+    }
+  }
+
+  console.log("\n");
+}
+
+export function discoverPatternAdd(options: {
+  category: string;
+  name: string;
+  scope: string;
+  appliesTo: string;
+  structure: string;
+  template: string;
+  examples: string;
+  antiPatterns?: string;
+  confidence?: number;
+  extractedFrom?: number;
+}): void {
+  initSchema();
+  const db = getDb();
+
+  // Verificar se pattern ja existe
+  const existing = db.query("SELECT id FROM implementation_patterns WHERE name = ?").get(options.name);
+  if (existing) {
+    console.error(`\nPattern '${options.name}' ja existe.`);
+    console.error("Use: discover pattern-edit para modificar\n");
+    process.exit(1);
+  }
+
+  const now = new Date().toISOString();
+
+  db.run(
+    `INSERT INTO implementation_patterns
+     (category, name, scope, applies_to, structure, template, examples, anti_patterns, confidence, extracted_from, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      options.category,
+      options.name,
+      options.scope,
+      options.appliesTo,
+      options.structure,
+      options.template,
+      options.examples,
+      options.antiPatterns || "[]",
+      options.confidence || 0.8,
+      options.extractedFrom || 1,
+      now,
+      now,
+    ]
+  );
+
+  // Regenerar patterns.md
+  generatePatternsMarkdown();
+
+  console.log(`\n✓ Pattern '${options.name}' adicionado com sucesso!`);
+  console.log("Arquivo atualizado: .codexa/patterns.md\n");
+}
+
+export function discoverPatternEdit(name: string, options: {
+  category?: string;
+  scope?: string;
+  appliesTo?: string;
+  structure?: string;
+  template?: string;
+  examples?: string;
+  antiPatterns?: string;
+  confidence?: number;
+}): void {
+  initSchema();
+  const db = getDb();
+
+  const existing = db.query("SELECT * FROM implementation_patterns WHERE name = ?").get(name) as any;
+  if (!existing) {
+    console.error(`\nPattern '${name}' nao encontrado.`);
+    console.error("Use: discover patterns para listar todos\n");
+    process.exit(1);
+  }
+
+  const updates: string[] = [];
+  const params: any[] = [];
+
+  if (options.category) {
+    updates.push("category = ?");
+    params.push(options.category);
+  }
+  if (options.scope) {
+    updates.push("scope = ?");
+    params.push(options.scope);
+  }
+  if (options.appliesTo) {
+    updates.push("applies_to = ?");
+    params.push(options.appliesTo);
+  }
+  if (options.structure) {
+    updates.push("structure = ?");
+    params.push(options.structure);
+  }
+  if (options.template) {
+    updates.push("template = ?");
+    params.push(options.template);
+  }
+  if (options.examples) {
+    updates.push("examples = ?");
+    params.push(options.examples);
+  }
+  if (options.antiPatterns) {
+    updates.push("anti_patterns = ?");
+    params.push(options.antiPatterns);
+  }
+  if (options.confidence !== undefined) {
+    updates.push("confidence = ?");
+    params.push(options.confidence);
+  }
+
+  if (updates.length === 0) {
+    console.error("\nNenhuma opcao de atualizacao fornecida.\n");
+    process.exit(1);
+  }
+
+  updates.push("updated_at = ?");
+  params.push(new Date().toISOString());
+  params.push(name);
+
+  db.run(
+    `UPDATE implementation_patterns SET ${updates.join(", ")} WHERE name = ?`,
+    params
+  );
+
+  // Regenerar patterns.md
+  generatePatternsMarkdown();
+
+  console.log(`\n✓ Pattern '${name}' atualizado com sucesso!`);
+  console.log("Arquivo atualizado: .codexa/patterns.md\n");
+}
+
+export function discoverPatternRemove(name: string): void {
+  initSchema();
+  const db = getDb();
+
+  const existing = db.query("SELECT id FROM implementation_patterns WHERE name = ?").get(name);
+  if (!existing) {
+    console.error(`\nPattern '${name}' nao encontrado.\n`);
+    process.exit(1);
+  }
+
+  db.run("DELETE FROM implementation_patterns WHERE name = ?", [name]);
+
+  // Regenerar patterns.md
+  generatePatternsMarkdown();
+
+  console.log(`\n✓ Pattern '${name}' removido com sucesso!`);
+  console.log("Arquivo atualizado: .codexa/patterns.md\n");
+}
+
+export function discoverRefreshPatterns(): void {
+  initSchema();
+  const db = getDb();
+
+  // Verificar se projeto foi descoberto
+  const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
+  if (!project) {
+    console.error("\nProjeto nao descoberto.");
+    console.error("Execute: discover start primeiro\n");
+    process.exit(1);
+  }
+
+  console.log("\n⚠ Refresh de patterns requer analise manual do codigo.");
+  console.log("Use o skill /codexa:discover para extrair patterns automaticamente.");
+  console.log("\nAlternativamente, adicione patterns manualmente:");
+  console.log("  discover pattern-add --category component --name my-pattern ...\n");
+}
+
+export function generatePatternsMarkdown(): void {
+  const db = getDb();
+  const patterns = db.query("SELECT * FROM implementation_patterns ORDER BY category, name").all() as any[];
+
+  if (patterns.length === 0) return;
+
+  let md = `# Implementation Patterns
+
+> Gerado automaticamente do SQLite. Nao edite manualmente.
+> Para modificar, use os comandos CLI.
+> Gerado em: ${new Date().toISOString()}
+
+## Resumo
+
+| Categoria | Nome | Arquivos | Confianca |
+|-----------|------|----------|-----------|
+`;
+
+  for (const p of patterns) {
+    const conf = ((p.confidence || 0) * 100).toFixed(0);
+    md += `| ${p.category} | ${p.name} | ${p.extracted_from || 0} | ${conf}% |\n`;
+  }
+
+  // Agrupar por categoria
+  const byCategory: Record<string, any[]> = {};
+  for (const p of patterns) {
+    if (!byCategory[p.category]) byCategory[p.category] = [];
+    byCategory[p.category].push(p);
+  }
+
+  for (const [category, categoryPatterns] of Object.entries(byCategory)) {
+    md += `\n## ${category.charAt(0).toUpperCase() + category.slice(1)}\n`;
+
+    for (const p of categoryPatterns) {
+      const structure = JSON.parse(p.structure || "{}");
+      const examples = JSON.parse(p.examples || "[]");
+      const antiPatterns = JSON.parse(p.anti_patterns || "[]");
+
+      md += `\n### ${p.name}\n\n`;
+      md += `- **Escopo:** ${p.scope}\n`;
+      md += `- **Aplica-se a:** \`${p.applies_to}\`\n`;
+      md += `- **Confianca:** ${((p.confidence || 0) * 100).toFixed(0)}%\n`;
+      md += `- **Extraido de:** ${p.extracted_from || 0} arquivos\n`;
+
+      if (structure.imports?.common?.length > 0) {
+        md += `\n**Imports comuns:**\n`;
+        for (const imp of structure.imports.common) {
+          md += `- \`${imp}\`\n`;
+        }
+      }
+
+      if (structure.patterns?.hooks_used?.length > 0) {
+        md += `\n**Hooks utilizados:** ${structure.patterns.hooks_used.join(", ")}\n`;
+      }
+
+      md += `\n**Template:**\n\n\`\`\`typescript\n${p.template}\n\`\`\`\n`;
+
+      if (examples.length > 0) {
+        md += `\n**Exemplos de referencia:**\n`;
+        for (const ex of examples.slice(0, 5)) {
+          const rel = ((ex.relevance || 0) * 100).toFixed(0);
+          md += `- \`${ex.path}\` (${rel}% similar)\n`;
+        }
+      }
+
+      if (antiPatterns.length > 0) {
+        md += `\n**⚠ Anti-patterns:**\n`;
+        for (const ap of antiPatterns) {
+          md += `- ❌ ${ap.description}\n`;
+          if (ap.found_in?.length > 0) {
+            md += `  - Encontrado em: ${ap.found_in.join(", ")}\n`;
+          }
+          if (ap.recommendation) {
+            md += `  - Recomendacao: ${ap.recommendation}\n`;
+          }
+        }
+      }
+    }
+  }
+
+  // Garantir que diretorio existe
+  const dir = join(process.cwd(), ".codexa");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  const mdPath = join(dir, "patterns.md");
+  writeFileSync(mdPath, md);
+}
+
+export function discoverExportPatterns(): void {
+  generatePatternsMarkdown();
+  console.log("\n✓ Arquivo .codexa/patterns.md regenerado!\n");
+}