@codexa/cli 8.6.14 → 9.0.1

package/commands/knowledge.ts

@@ -359,4 +359,55 @@ export function queryGraph(options: {
   console.log(`  knowledge graph --file <path>           Relacoes de um arquivo`);
   console.log(`  knowledge graph --decision <id>         Arquivos afetados por decisao`);
   console.log(`  knowledge graph --contradictions        Detectar contradicoes\n`);
+}
+
+// v9.0: Resolver/reconhecer knowledge critico (para desbloquear task start)
+export function resolveKnowledge(ids: string, resolution?: string): void {
+  initSchema();
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  const spec = getActiveSpec();
+  if (!spec) {
+    console.error("\nNenhuma feature ativa.\n");
+    process.exit(1);
+  }
+
+  const knowledgeIds = ids.split(",").map(s => parseInt(s.trim()));
+
+  for (const kid of knowledgeIds) {
+    const knowledge = db.query("SELECT * FROM knowledge WHERE id = ?").get(kid) as any;
+
+    if (!knowledge) {
+      console.error(`Knowledge #${kid} nao encontrado.`);
+      continue;
+    }
+
+    const acknowledged = knowledge.acknowledged_by
+      ? (JSON.parse(knowledge.acknowledged_by) as number[])
+      : [];
+
+    // Usar -1 como marker de "resolvido pelo orquestrador"
+    if (!acknowledged.includes(-1)) {
+      acknowledged.push(-1);
+    }
+
+    db.run(
+      "UPDATE knowledge SET acknowledged_by = ? WHERE id = ?",
+      [JSON.stringify(acknowledged), kid]
+    );
+
+    console.log(`Knowledge #${kid} resolvido.`);
+  }
+
+  if (resolution) {
+    db.run(
+      `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
+       VALUES (?, 0, 'decision', ?, 'info', 'all', ?)`,
+      [spec.id, `Resolucao de blockers: ${resolution}`, now]
+    );
+    console.log(`Resolucao registrada como knowledge.`);
+  }
+
+  console.log();
 }

package/commands/patterns.ts

@@ -31,6 +31,10 @@ interface ExtractedPattern {
     commonImports: string[];
     commonExports: string[];
     conventions: string[];
+    // v9.0
+    commonHooks: string[];
+    commonReactPatterns: string[];
+    hasTypes: boolean;
   };
   template: string;
   examples: Array<{ path: string; relevance: number }>;
@@ -68,6 +72,23 @@ const PATTERN_QUERIES: PatternQuery[] = [
   // 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" },
 ];
 
 // ═══════════════════════════════════════════════════════════════
@@ -122,6 +143,11 @@ interface FileAnalysis {
   hasNamedExports: boolean;
   conventions: string[];
   size: number;
+  // v9.0: Metadata complementar ao grepai
+  directives: string[];
+  hooksUsed: string[];
+  reactPatterns: string[];
+  hasTypeExports: boolean;
 }
 
 function analyzeFile(filePath: string): FileAnalysis | null {
@@ -134,19 +160,34 @@ function analyzeFile(filePath: string): FileAnalysis | null {
     const imports: string[] = [];
     const exports: string[] = [];
     const conventions: string[] = [];
+    const hooksUsed: string[] = [];
+    const reactPatterns: string[] = [];
+    const directives: string[] = [];
 
     let hasDefaultExport = false;
     let hasNamedExports = false;
+    let hasTypeExports = false;
 
     for (const line of lines) {
       const trimmed = line.trim();
 
-      // Extrair imports
+      // Extrair imports (modulo)
       const importMatch = trimmed.match(/^import\s+.*\s+from\s+['"]([^'"]+)['"]/);
       if (importMatch) {
         imports.push(importMatch[1]);
       }
 
+      // Extrair hooks dos imports: import { useX, useY } from "..."
+      const hooksInImport = trimmed.match(/^import\s+\{([^}]+)\}\s+from/);
+      if (hooksInImport) {
+        const specifiers = hooksInImport[1].split(",").map(s => s.trim());
+        for (const spec of specifiers) {
+          if (/^use[A-Z]\w*$/.test(spec)) {
+            hooksUsed.push(spec);
+          }
+        }
+      }
+
       // Extrair exports
       if (trimmed.startsWith("export default")) {
         hasDefaultExport = true;
@@ -157,17 +198,48 @@ function analyzeFile(filePath: string): FileAnalysis | null {
         if (exportMatch) {
           exports.push(exportMatch[1]);
         }
+        if (trimmed.startsWith("export type ") || trimmed.startsWith("export interface ")) {
+          hasTypeExports = true;
+        }
       }
 
-      // Detectar convenções
-      if (trimmed.includes("'use client'") || trimmed.includes('"use client"')) {
+      // Directives
+      if (trimmed === "'use client'" || trimmed === '"use client"') {
+        directives.push("use client");
         conventions.push("use client");
       }
-      if (trimmed.includes("'use server'") || trimmed.includes('"use server"')) {
+      if (trimmed === "'use server'" || trimmed === '"use server"') {
+        directives.push("use server");
         conventions.push("use server");
       }
+      if (trimmed === "'use cache'" || trimmed === '"use cache"') {
+        directives.push("use cache");
+        conventions.push("use cache");
+      }
+
+      // Async patterns
       if (trimmed.includes("async function") || trimmed.includes("async (")) {
-        conventions.push("async");
+        if (!conventions.includes("async")) conventions.push("async");
+      }
+
+      // React patterns (metadata complementar ao grepai)
+      if (trimmed.includes("forwardRef") && !reactPatterns.includes("forwardRef")) {
+        reactPatterns.push("forwardRef");
+      }
+      if (trimmed.includes("createContext") && !reactPatterns.includes("createContext")) {
+        reactPatterns.push("createContext");
+      }
+      if (trimmed.includes("ErrorBoundary") && !reactPatterns.includes("ErrorBoundary")) {
+        reactPatterns.push("ErrorBoundary");
+      }
+      if (trimmed.includes("Suspense") && !reactPatterns.includes("Suspense")) {
+        reactPatterns.push("Suspense");
+      }
+      if (trimmed.includes("memo(") && !reactPatterns.includes("memo")) {
+        reactPatterns.push("memo");
+      }
+      if (trimmed.includes("lazy(") && !reactPatterns.includes("lazy")) {
+        reactPatterns.push("lazy");
       }
     }
 
@@ -179,6 +251,10 @@ function analyzeFile(filePath: string): FileAnalysis | null {
       hasNamedExports,
       conventions: [...new Set(conventions)],
       size: content.length,
+      directives: [...new Set(directives)],
+      hooksUsed: [...new Set(hooksUsed)],
+      reactPatterns: [...new Set(reactPatterns)],
+      hasTypeExports,
     };
   } catch {
     return null;
@@ -303,23 +379,28 @@ function findCommonElements<T>(arrays: T[][]): T[] {
 
 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 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 de cliente/servidor
+  // 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
+  // Imports comuns (max 5)
   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("~/")) {
@@ -329,37 +410,69 @@ function generateTemplate(analyses: FileAnalysis[], category: string): string {
     template += "\n";
   }
 
-  // Estrutura baseada na categoria
+  // Estrutura baseada na categoria + dados reais dos arquivos
   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}`;
+    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  // Estado e lógica\n  \n  return {\n    // Valores e funções\n  }\n}`;
+      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  // 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}`;
+      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    // Inicialização\n  }\n\n  async execute() {\n    // Lógica do serviço\n  }\n}`;
+      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  // Validação\n  \n  // Lógica\n  \n  // Retorno\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":
@@ -367,6 +480,38 @@ function generateTemplate(analyses: FileAnalysis[], category: string): string {
       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`;
   }
@@ -402,14 +547,18 @@ function extractPatternFromFiles(
   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 confiança baseada em quantos arquivos seguem o pattern
+  // 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 único
+  // Gerar nome unico
   const name = `${query.scope}-${query.category}-pattern`;
 
   return {
@@ -421,13 +570,16 @@ function extractPatternFromFiles(
       commonImports,
       commonExports,
       conventions: commonConventions,
+      commonHooks,
+      commonReactPatterns,
+      hasTypes,
     },
     template,
     examples: files.slice(0, 5).map((f) => ({
       path: f.path,
       relevance: f.score || 0.8,
     })),
-    antiPatterns: [], // Será preenchido se detectarmos inconsistências
+    antiPatterns: [],
     confidence,
     extractedFrom: analyses.length,
   };
@@ -611,11 +763,241 @@ export function patternsAnalyze(filePath: string, json: boolean = false): void {
   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"}`);
+  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(`  - Diretivas: ${analysis.conventions.join(", ")}`);
+    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) {
+    console.error("\nNenhum arquivo analisado.\n");
+    process.exit(1);
+  }
+
+  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
+// ═══════════════════════════════════════════════════════════════
+
+export function updatePatternsIncremental(files: string[], taskNumber: number): void {
+  initSchema();
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  const allPatterns = db.query("SELECT * FROM implementation_patterns").all() as any[];
+  if (allPatterns.length === 0) return;
+
+  for (const file of files) {
+    const analysis = analyzeFile(file);
+    if (!analysis) continue;
+
+    for (const pattern of allPatterns) {
+      if (!fileMatchesGlob(file, pattern.applies_to)) continue;
+
+      const examples: Array<{ path: string; relevance: number }> = JSON.parse(pattern.examples || "[]");
+      if (!examples.some((e: { path: string }) => e.path === file)) {
+        examples.push({ path: file, relevance: 0.7 });
+        if (examples.length > 10) examples.shift();
+      }
+
+      const structure = JSON.parse(pattern.structure);
+      let structureChanged = false;
+
+      if (structure.commonHooks && analysis.hooksUsed.length > 0) {
+        for (const hook of analysis.hooksUsed) {
+          if (!structure.commonHooks.includes(hook)) {
+            structure.commonHooks.push(hook);
+            structureChanged = true;
+          }
+        }
+      }
+
+      if (structure.commonReactPatterns && analysis.reactPatterns.length > 0) {
+        for (const rp of analysis.reactPatterns) {
+          if (!structure.commonReactPatterns.includes(rp)) {
+            structure.commonReactPatterns.push(rp);
+            structureChanged = true;
+          }
+        }
+      }
+
+      const newExtractedFrom = (pattern.extracted_from || 0) + 1;
+      const newConfidence = Math.min(newExtractedFrom / 10, 1);
+
+      db.run(
+        `UPDATE implementation_patterns
+         SET examples = ?, extracted_from = ?, confidence = ?,
+             structure = ?, updated_at = ?
+         WHERE id = ?`,
+        [
+          JSON.stringify(examples),
+          newExtractedFrom,
+          newConfidence,
+          structureChanged ? JSON.stringify(structure) : pattern.structure,
+          now,
+          pattern.id,
+        ]
+      );
+      break;
+    }
+  }
+}
+
+function fileMatchesGlob(filePath: string, glob: string): boolean {
+  const normalized = filePath.replace(/\\/g, "/");
+  const regexStr = glob
+    .replace(/\./g, "\\.")
+    .replace(/\*\*/g, "<<DOUBLESTAR>>")
+    .replace(/\*/g, "[^/]*")
+    .replace(/<<DOUBLESTAR>>/g, ".*");
+  try {
+    return new RegExp(regexStr).test(normalized);
+  } catch {
+    return false;
+  }
+}