ultracode 5.3.0 → 5.5.0

package/dist/chunks/pattern-tool-handlers-L62W3CXR.js

@@ -0,0 +1,1549 @@
+import { DetectPatternsSchema, CheckEntityPatternsSchema } from './chunk-NEXEPPHU.js';
+import { BaseToolHandler } from './chunk-WLKASYMP.js';
+import './chunk-KMXE2SJJ.js';
+import { cosineSimilarity } from './chunk-QN237S7C.js';
+import './chunk-ZD54CMKT.js';
+import './chunk-HEMJHRHZ.js';
+import { toError } from './chunk-5WKPA33T.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import { __export } from './chunk-NAQKA54E.js';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import { readdirSync, readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import YAML from 'yaml';
+import { z } from 'zod';
+
+// src/analysis/patterns/pattern-engine.ts
+init_logging();
+
+// src/analysis/patterns/detectors/common.ts
+var common_exports = {};
+__export(common_exports, {
+  checkDeepNesting: () => checkDeepNesting,
+  checkGodFunction: () => checkGodFunction,
+  checkLargeClass: () => checkLargeClass,
+  checkNoDocumentation: () => checkNoDocumentation,
+  checkSmallFocusedFunction: () => checkSmallFocusedFunction,
+  checkTooManyParams: () => checkTooManyParams
+});
+function checkGodFunction(entity) {
+  const mods = entity.metadata?.modifiers ?? [];
+  if (mods.includes("partial")) return { match: false, confidence: 0 };
+  const metrics = entity.metadata?.["metrics"];
+  const cyclomatic = metrics?.cyclomaticComplexity ?? 0;
+  const loc = metrics?.linesOfCode ?? 0;
+  const matched = [];
+  if (cyclomatic > 20) matched.push(`cyclomatic=${cyclomatic}`);
+  if (loc > 200) matched.push(`LOC=${loc}`);
+  if (matched.length === 0) return { match: false, confidence: 0 };
+  const confidence = matched.length === 2 ? 0.95 : 0.8;
+  return { match: true, confidence, matchedCriteria: matched };
+}
+function checkDeepNesting(entity) {
+  const metrics = entity.metadata?.["metrics"];
+  const depth = metrics?.nestingDepth ?? 0;
+  if (depth <= 5) return { match: false, confidence: 0 };
+  return {
+    match: true,
+    confidence: Math.min(0.5 + (depth - 5) * 0.1, 1),
+    matchedCriteria: [`nestingDepth=${depth}`]
+  };
+}
+function checkTooManyParams(entity) {
+  const params = entity.metadata?.parameters ?? [];
+  if (params.length <= 7) return { match: false, confidence: 0 };
+  const mods = entity.metadata?.modifiers ?? [];
+  if (mods.includes("constructor") || mods.includes("partial")) {
+    return { match: false, confidence: 0 };
+  }
+  const interfaceParams = params.filter((p) => p.type && /^I[A-Z]/.test(p.type)).length;
+  if (params.length > 0 && interfaceParams / params.length >= 0.7) {
+    return { match: false, confidence: 0 };
+  }
+  return {
+    match: true,
+    confidence: Math.min(0.6 + (params.length - 7) * 0.05, 1),
+    matchedCriteria: [`paramCount=${params.length}`]
+  };
+}
+function checkNoDocumentation(entity) {
+  const mods = entity.metadata?.modifiers ?? [];
+  const isPublic = mods.includes("public") || mods.includes("export") || mods.includes("exported");
+  if (!isPublic) return { match: false, confidence: 0 };
+  if (mods.includes("partial")) return { match: false, confidence: 0 };
+  if (mods.includes("internal")) return { match: false, confidence: 0 };
+  const fp = entity.filePath;
+  if (/[\\/](Minimal|Internal|Hosting|Kestrel|Middleware|Extensions)\b/i.test(fp)) {
+    return { match: false, confidence: 0 };
+  }
+  const signature = entity.metadata?.signature;
+  const hasJsdoc = signature?.includes("/**") ?? false;
+  const hasDocstring = entity.metadata?.["documentation"] != null || entity.metadata?.["description"] != null;
+  if (hasJsdoc || hasDocstring) return { match: false, confidence: 0 };
+  return {
+    match: true,
+    confidence: 0.7,
+    matchedCriteria: ["public-no-docs"]
+  };
+}
+function checkSmallFocusedFunction(entity) {
+  const metrics = entity.metadata?.["metrics"];
+  const cyclomatic = metrics?.cyclomaticComplexity ?? 0;
+  const loc = metrics?.linesOfCode ?? 0;
+  if (loc < 3) return { match: false, confidence: 0 };
+  const matched = [];
+  if (loc <= 30) matched.push(`LOC=${loc}`);
+  if (cyclomatic <= 5) matched.push(`cyclomatic=${cyclomatic}`);
+  if (matched.length < 2) return { match: false, confidence: 0 };
+  return { match: true, confidence: 0.85, matchedCriteria: matched };
+}
+function checkLargeClass(entity) {
+  if (entity.type !== "class") return { match: false, confidence: 0 };
+  const metrics = entity.metadata?.["metrics"];
+  const loc = metrics?.linesOfCode ?? 0;
+  const methodCount = entity.metadata?.["metrics"]?.methodCount ?? 0;
+  const matched = [];
+  if (loc > 500) matched.push(`LOC=${loc}`);
+  if (methodCount > 20) matched.push(`methods=${methodCount}`);
+  if (loc <= 500) return { match: false, confidence: 0 };
+  return {
+    match: true,
+    confidence: matched.length === 2 ? 0.9 : 0.7,
+    matchedCriteria: matched
+  };
+}
+
+// src/analysis/patterns/exemplar-store.ts
+init_logging();
+var ExemplarStore = class {
+  constructor(exemplarsDir, cacheDir) {
+    this.exemplarsDir = exemplarsDir;
+    this.cacheDir = cacheDir ?? join(process.cwd(), ".cache");
+  }
+  exemplars = /* @__PURE__ */ new Map();
+  exemplarsByPattern = /* @__PURE__ */ new Map();
+  embeddings = /* @__PURE__ */ new Map();
+  loaded = false;
+  embedded = false;
+  cacheDir;
+  /**
+   * Load exemplar YAML files
+   */
+  async load(exemplarsDir) {
+    if (this.loaded) return;
+    const dir = exemplarsDir ?? this.exemplarsDir ?? join(import.meta.dirname, "exemplars");
+    let files;
+    try {
+      files = readdirSync(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    } catch {
+      log.w("EXEMPLAR_STORE", "dir_not_found", { dir });
+      this.loaded = true;
+      return;
+    }
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(dir, file), "utf-8");
+        const raw = YAML.parse(content);
+        if (!raw?.exemplars) continue;
+        for (const ex of raw.exemplars) {
+          const exemplar = {
+            id: ex.id,
+            patternId: ex.patternId,
+            language: ex.language,
+            code: ex.code.slice(0, 400),
+            // Enforce limit
+            description: ex.description
+          };
+          this.exemplars.set(ex.id, exemplar);
+          const patternList = this.exemplarsByPattern.get(ex.patternId) ?? [];
+          patternList.push(exemplar);
+          this.exemplarsByPattern.set(ex.patternId, patternList);
+        }
+        log.i("EXEMPLAR_STORE", "loaded_file", { file, count: raw.exemplars.length });
+      } catch (err) {
+        log.e("EXEMPLAR_STORE", "load_error", { file, error: String(err) });
+      }
+    }
+    this.loaded = true;
+    log.i("EXEMPLAR_STORE", "store_ready", { total: this.exemplars.size });
+  }
+  /**
+   * Lazy-embed all exemplars (called on first detect_patterns)
+   */
+  async ensureEmbeddings(embeddingGen) {
+    if (this.embedded || this.exemplars.size === 0) return;
+    const currentHash = this.computeHash();
+    const cacheFile = join(this.cacheDir, "pattern-exemplar-embeddings.json");
+    if (this.tryLoadCache(cacheFile, currentHash)) {
+      this.embedded = true;
+      log.i("EXEMPLAR_STORE", "cache_hit", { exemplars: this.embeddings.size });
+      return;
+    }
+    log.i("EXEMPLAR_STORE", "generating_embeddings", { count: this.exemplars.size });
+    const startMs = Date.now();
+    for (const [id, exemplar] of this.exemplars) {
+      try {
+        const embedding = await embeddingGen.generateCodeEmbedding(exemplar.code, exemplar.language);
+        this.embeddings.set(id, embedding);
+      } catch (err) {
+        log.w("EXEMPLAR_STORE", "embed_error", { id, error: String(err) });
+      }
+    }
+    log.i("EXEMPLAR_STORE", "embeddings_generated", {
+      count: this.embeddings.size,
+      durationMs: Date.now() - startMs
+    });
+    this.saveCache(cacheFile, currentHash);
+    this.embedded = true;
+  }
+  /**
+   * Find similar exemplars for a given entity embedding and pattern
+   */
+  findSimilarExemplars(entityEmbedding, patternId, limit = 1) {
+    const exemplars = this.exemplarsByPattern.get(patternId) ?? [];
+    if (exemplars.length === 0) return [];
+    const results = [];
+    for (const ex of exemplars) {
+      const exEmbedding = this.embeddings.get(ex.id);
+      if (!exEmbedding) continue;
+      const similarity = cosineSimilarity(entityEmbedding, exEmbedding);
+      results.push({ id: ex.id, similarity, description: ex.description });
+    }
+    return results.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+  }
+  /**
+   * Get exemplar by ID
+   */
+  get(id) {
+    return this.exemplars.get(id);
+  }
+  /**
+   * Get exemplars for a pattern
+   */
+  getForPattern(patternId) {
+    return this.exemplarsByPattern.get(patternId) ?? [];
+  }
+  get size() {
+    return this.exemplars.size;
+  }
+  // ─── Cache Management ────────────────────────────────────────────
+  computeHash() {
+    const codes = [...this.exemplars.values()].map((e) => e.code).sort().join("|");
+    return createHash("sha256").update(codes).digest("hex").slice(0, 16);
+  }
+  tryLoadCache(cacheFile, expectedHash) {
+    try {
+      if (!existsSync(cacheFile)) return false;
+      const data = JSON.parse(readFileSync(cacheFile, "utf-8"));
+      if (data.hash !== expectedHash) return false;
+      for (const [id, base64] of Object.entries(data.embeddings)) {
+        if (!this.exemplars.has(id)) continue;
+        const buffer = Buffer.from(base64, "base64");
+        this.embeddings.set(id, new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4));
+      }
+      return this.embeddings.size > 0;
+    } catch {
+      return false;
+    }
+  }
+  saveCache(cacheFile, hash) {
+    try {
+      if (!existsSync(this.cacheDir)) {
+        mkdirSync(this.cacheDir, { recursive: true });
+      }
+      const data = {
+        hash,
+        embeddings: {}
+      };
+      for (const [id, embedding] of this.embeddings) {
+        const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+        data.embeddings[id] = buf.toString("base64");
+      }
+      writeFileSync(cacheFile, JSON.stringify(data), "utf-8");
+      log.i("EXEMPLAR_STORE", "cache_saved", { file: cacheFile, count: this.embeddings.size });
+    } catch (err) {
+      log.w("EXEMPLAR_STORE", "cache_save_error", { error: String(err) });
+    }
+  }
+};
+
+// src/analysis/patterns/pattern-registry.ts
+init_logging();
+var RelationshipCriteriaSchema = z.object({
+  type: z.string(),
+  direction: z.enum(["incoming", "outgoing"]),
+  minCount: z.number().optional(),
+  maxCount: z.number().optional(),
+  crossFileRatio: z.object({
+    min: z.number().optional(),
+    max: z.number().optional()
+  }).optional()
+});
+var StructuralCriteriaSchema = z.object({
+  entityTypes: z.array(z.string()).optional(),
+  requiredModifiers: z.array(z.string()).optional(),
+  forbiddenModifiers: z.array(z.string()).optional(),
+  returnTypeMatch: z.string().optional(),
+  returnTypeNotMatch: z.string().optional(),
+  minParams: z.number().optional(),
+  maxParams: z.number().optional(),
+  paramTypeRequired: z.string().optional(),
+  paramTypeAbsent: z.string().optional(),
+  minCyclomatic: z.number().optional(),
+  maxCyclomatic: z.number().optional(),
+  minCognitive: z.number().optional(),
+  minNesting: z.number().optional(),
+  minLOC: z.number().optional(),
+  maxLOC: z.number().optional(),
+  hasLoops: z.boolean().optional(),
+  hasExceptions: z.boolean().optional(),
+  hasAwaits: z.boolean().optional(),
+  minBranches: z.number().optional(),
+  minCallCount: z.number().optional(),
+  callsInclude: z.array(z.string()).optional(),
+  callsExclude: z.array(z.string()).optional(),
+  decoratorMatch: z.array(z.string()).optional(),
+  hasNoInheritance: z.boolean().optional(),
+  filePathNotMatch: z.string().optional(),
+  nameMatch: z.string().optional(),
+  nameNotMatch: z.string().optional(),
+  relationships: z.array(RelationshipCriteriaSchema).optional()
+});
+var PatternDefinitionSchema = z.object({
+  id: z.string(),
+  language: z.string().optional(),
+  // Inferred from filename if absent
+  category: z.enum(["anti-pattern", "best-pattern", "code-smell", "optimization"]),
+  severity: z.enum(["critical", "high", "medium", "low", "info"]),
+  name: z.string(),
+  description: z.string(),
+  suggestion: z.string(),
+  bigO: z.object({
+    before: z.string(),
+    after: z.string()
+  }).optional(),
+  benchmark: z.string().optional(),
+  tags: z.array(z.string()).default([]),
+  enabled: z.boolean().default(true),
+  structural: StructuralCriteriaSchema.optional(),
+  customDetector: z.string().optional(),
+  exemplarIds: z.array(z.string()).optional(),
+  minSemanticSimilarity: z.number().default(0),
+  minStructuralConfidence: z.number().default(0.6)
+});
+var PatternFileSchema = z.object({
+  patterns: z.array(PatternDefinitionSchema)
+});
+var PatternRegistry = class {
+  constructor(rulesDir) {
+    this.rulesDir = rulesDir;
+  }
+  patterns = /* @__PURE__ */ new Map();
+  allPatterns = /* @__PURE__ */ new Map();
+  loaded = false;
+  /**
+   * Load all YAML rule files. Call once before using.
+   */
+  async load(rulesDir) {
+    if (this.loaded) return;
+    const dir = rulesDir ?? this.rulesDir ?? join(import.meta.dirname, "rules");
+    let files;
+    try {
+      files = readdirSync(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    } catch {
+      log.w("PATTERN_REGISTRY", "rules_dir_not_found", { dir });
+      this.loaded = true;
+      return;
+    }
+    for (const file of files) {
+      const language = file.replace(/\.ya?ml$/, "");
+      try {
+        const content = readFileSync(join(dir, file), "utf-8");
+        const raw = YAML.parse(content);
+        const parsed = PatternFileSchema.parse(raw);
+        const definitions = parsed.patterns.map((p) => ({
+          ...p,
+          language: p.language ?? language
+        }));
+        const existing = this.patterns.get(language) ?? [];
+        this.patterns.set(language, [...existing, ...definitions]);
+        for (const def of definitions) {
+          if (this.allPatterns.has(def.id)) {
+            log.w("PATTERN_REGISTRY", "duplicate_pattern_id", { id: def.id });
+          }
+          this.allPatterns.set(def.id, def);
+        }
+        log.i("PATTERN_REGISTRY", "loaded_rules", { file, count: definitions.length });
+      } catch (err) {
+        log.e("PATTERN_REGISTRY", "load_error", { file, error: String(err) });
+      }
+    }
+    this.loaded = true;
+    log.i("PATTERN_REGISTRY", "registry_ready", {
+      languages: this.patterns.size,
+      totalPatterns: this.allPatterns.size
+    });
+  }
+  /**
+   * Get patterns filtered by criteria. Always includes "common" patterns.
+   */
+  getPatterns(options) {
+    const { language, category = "all", tags, enabledOnly = true } = options;
+    let result = [];
+    if (language) {
+      result = [...this.patterns.get(language) ?? [], ...this.patterns.get("common") ?? []];
+    } else {
+      result = [...this.allPatterns.values()];
+    }
+    if (enabledOnly) {
+      result = result.filter((p) => p.enabled);
+    }
+    if (category !== "all") {
+      result = result.filter((p) => p.category === category);
+    }
+    if (tags && tags.length > 0) {
+      result = result.filter((p) => tags.some((t) => p.tags.includes(t)));
+    }
+    return result;
+  }
+  /**
+   * Get a single pattern by ID
+   */
+  getPattern(id) {
+    return this.allPatterns.get(id);
+  }
+  /**
+   * Get all unique language keys
+   */
+  getLanguages() {
+    return [...this.patterns.keys()];
+  }
+  /**
+   * Total loaded pattern count
+   */
+  get size() {
+    return this.allPatterns.size;
+  }
+};
+
+// src/analysis/patterns/semantic-validator.ts
+init_logging();
+var SemanticValidator = class {
+  constructor(exemplarStore, embeddingGen) {
+    this.exemplarStore = exemplarStore;
+    this.embeddingGen = embeddingGen;
+  }
+  /**
+   * Validate structural candidates with semantic similarity
+   *
+   * @returns Confirmed PatternMatch[] with combined scores
+   */
+  async validate(candidates, _patternMap) {
+    const results = [];
+    const needsSemantic = candidates.filter((c) => c.pattern.minSemanticSimilarity > 0);
+    const structuralOnly = candidates.filter((c) => c.pattern.minSemanticSimilarity === 0);
+    for (const c of structuralOnly) {
+      results.push(this.createMatch(c, 1, void 0));
+    }
+    if (needsSemantic.length > 0) {
+      if (this.embeddingGen) {
+        await this.exemplarStore.ensureEmbeddings(this.embeddingGen);
+      }
+      for (const c of needsSemantic) {
+        const entityEmbedding = await this.getEntityEmbedding(c);
+        if (!entityEmbedding) {
+          if (c.confidence >= c.pattern.minStructuralConfidence) {
+            results.push(this.createMatch(c, -1, void 0));
+          }
+          continue;
+        }
+        const exemplarResults = this.exemplarStore.findSimilarExemplars(entityEmbedding, c.pattern.id, 1);
+        const topExemplar = exemplarResults[0];
+        const similarity = topExemplar?.similarity ?? 0;
+        if (similarity >= c.pattern.minSemanticSimilarity) {
+          results.push(this.createMatch(c, similarity, topExemplar));
+        }
+      }
+    }
+    log.i("SEMANTIC_VALIDATOR", "validation_complete", {
+      candidates: candidates.length,
+      confirmed: results.length,
+      structuralOnly: structuralOnly.length,
+      semanticValidated: needsSemantic.length
+    });
+    return results;
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────
+  createMatch(candidate, semanticSimilarity, closestExemplar) {
+    const isStructuralOnly = candidate.pattern.minSemanticSimilarity === 0;
+    const noSemanticData = semanticSimilarity < 0;
+    const combinedScore = isStructuralOnly || noSemanticData ? candidate.confidence : candidate.confidence * 0.4 + semanticSimilarity * 0.6;
+    return {
+      patternId: candidate.pattern.id,
+      pattern: candidate.pattern,
+      entityId: candidate.entity.id,
+      entityName: candidate.entity.name,
+      entityType: candidate.entity.type,
+      filePath: candidate.entity.filePath,
+      line: candidate.entity.location?.start?.line ?? 0,
+      structuralConfidence: candidate.confidence,
+      semanticSimilarity: isStructuralOnly ? 1 : noSemanticData ? 0 : semanticSimilarity,
+      combinedScore,
+      matchedCriteria: candidate.matchedCriteria,
+      closestExemplar: closestExemplar ? { id: closestExemplar.id, similarity: closestExemplar.similarity, description: closestExemplar.description } : void 0
+    };
+  }
+  async getEntityEmbedding(candidate) {
+    const base64 = candidate.entity.embeddingBase64;
+    if (base64) {
+      try {
+        const buffer = Buffer.from(base64, "base64");
+        return new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4);
+      } catch {
+      }
+    }
+    if (this.embeddingGen) {
+      try {
+        const text = candidate.entity.embeddingText ?? candidate.entity.name;
+        const language = candidate.entity.language ?? candidate.entity.metadata?.language;
+        return await this.embeddingGen.generateCodeEmbedding(text, language);
+      } catch (err) {
+        log.w("SEMANTIC_VALIDATOR", "embed_error", {
+          entity: candidate.entity.id,
+          error: String(err)
+        });
+      }
+    }
+    return null;
+  }
+};
+
+// src/analysis/patterns/structural-detector.ts
+init_logging();
+var detectorRegistry = /* @__PURE__ */ new Map();
+function registerDetectors(detectors) {
+  for (const [name, fn] of Object.entries(detectors)) {
+    detectorRegistry.set(name, fn);
+  }
+}
+var compiledCache = /* @__PURE__ */ new WeakMap();
+function getCompiled(pattern) {
+  let compiled = compiledCache.get(pattern);
+  if (compiled) return compiled;
+  const c = pattern.structural;
+  compiled = {
+    entityTypeSet: c?.entityTypes ? new Set(c.entityTypes) : null,
+    returnTypeMatchRe: c?.returnTypeMatch ? new RegExp(c.returnTypeMatch, "i") : null,
+    returnTypeNotMatchRe: c?.returnTypeNotMatch ? new RegExp(c.returnTypeNotMatch, "i") : null,
+    paramTypeRequiredRe: c?.paramTypeRequired ? new RegExp(c.paramTypeRequired, "i") : null,
+    paramTypeAbsentRe: c?.paramTypeAbsent ? new RegExp(c.paramTypeAbsent, "i") : null,
+    callsIncludeRe: c?.callsInclude ? c.callsInclude.map((p) => new RegExp(p, "i")) : null,
+    callsExcludeRe: c?.callsExclude ? c.callsExclude.map((p) => new RegExp(p, "i")) : null,
+    decoratorMatchRe: c?.decoratorMatch ? c.decoratorMatch.map((p) => new RegExp(p, "i")) : null,
+    nameMatchRe: c?.nameMatch ? new RegExp(c.nameMatch, "i") : null,
+    nameNotMatchRe: c?.nameNotMatch ? new RegExp(c.nameNotMatch, "i") : null,
+    filePathNotMatchRe: c?.filePathNotMatch ? new RegExp(c.filePathNotMatch, "i") : null,
+    totalCriteriaCount: countTotalCriteria(c ?? {})
+  };
+  compiledCache.set(pattern, compiled);
+  return compiled;
+}
+var metaCache = /* @__PURE__ */ new WeakMap();
+function getMeta(entity) {
+  let meta = metaCache.get(entity);
+  if (meta) return meta;
+  const md = entity.metadata;
+  const metricsRaw = md?.["metrics"];
+  const cfRaw = md?.["controlFlow"];
+  const callsRaw = md?.["calls"] ?? [];
+  const decsRaw = md?.decorators ?? [];
+  const inheritanceRaw = md?.["inheritance"];
+  meta = {
+    modifiers: md?.modifiers ?? [],
+    returnType: md?.returnType,
+    params: md?.parameters ?? [],
+    metrics: {
+      cyclomaticComplexity: metricsRaw?.["cyclomaticComplexity"] ?? 0,
+      cognitiveComplexity: metricsRaw?.["cognitiveComplexity"] ?? 0,
+      linesOfCode: metricsRaw?.["linesOfCode"] ?? 0,
+      nestingDepth: metricsRaw?.["nestingDepth"] ?? 0
+    },
+    cf: {
+      branches: cfRaw?.["branches"]?.length ?? 0,
+      loops: cfRaw?.["loops"]?.length ?? 0,
+      exceptions: cfRaw?.["exceptions"]?.length ?? 0,
+      awaits: cfRaw?.["awaits"]?.length ?? 0
+    },
+    callNames: callsRaw.map((c) => `${c.target ?? ""}.${c.name ?? ""}`),
+    decoratorNames: decsRaw.map((d) => d.name),
+    hasInheritance: (inheritanceRaw?.baseClasses?.length ?? 0) > 0 || (inheritanceRaw?.interfaces?.length ?? 0) > 0
+  };
+  metaCache.set(entity, meta);
+  return meta;
+}
+var EVAL_ZERO = { confidence: 0, matchedCriteria: [] };
+var StructuralDetector = class {
+  // Cache: entityId:patternId -> evaluation result (3B)
+  evalCache = /* @__PURE__ */ new Map();
+  /** Clear evaluation cache (call when entities or patterns change) */
+  clearEvalCache() {
+    this.evalCache.clear();
+  }
+  async detect(entities, patterns, storage) {
+    const candidates = [];
+    const entitiesByType = /* @__PURE__ */ new Map();
+    for (const entity of entities) {
+      const arr = entitiesByType.get(entity.type);
+      if (arr) arr.push(entity);
+      else entitiesByType.set(entity.type, [entity]);
+    }
+    const metadataCandidates = [];
+    for (const pattern of patterns) {
+      const compiled = getCompiled(pattern);
+      let entitiesToCheck;
+      if (compiled.entityTypeSet) {
+        entitiesToCheck = [];
+        for (const type of compiled.entityTypeSet) {
+          const arr = entitiesByType.get(type);
+          if (arr) entitiesToCheck.push(...arr);
+        }
+      } else {
+        entitiesToCheck = entities;
+      }
+      for (const entity of entitiesToCheck) {
+        const result = this.evaluateMetadataCriteria(entity, pattern, compiled);
+        if (result.confidence > 0) {
+          metadataCandidates.push({
+            entity,
+            pattern,
+            confidence: result.confidence,
+            matched: result.matchedCriteria
+          });
+        }
+      }
+    }
+    const needsGraph = metadataCandidates.filter(
+      (c) => c.pattern.structural?.relationships && c.pattern.structural.relationships.length > 0
+    );
+    const noGraph = metadataCandidates.filter(
+      (c) => !c.pattern.structural?.relationships || c.pattern.structural.relationships.length === 0
+    );
+    for (const c of noGraph) {
+      if (c.confidence >= c.pattern.minStructuralConfidence) {
+        candidates.push({
+          entity: c.entity,
+          pattern: c.pattern,
+          confidence: c.confidence,
+          matchedCriteria: c.matched
+        });
+      }
+    }
+    if (needsGraph.length > 0 && storage) {
+      const entityIds = [...new Set(needsGraph.map((c) => c.entity.id))];
+      let allRels = [];
+      try {
+        const [outgoing, incoming] = await Promise.all([
+          storage.findRelationships({ filters: { fromId: entityIds }, limit: 1e4 }),
+          storage.findRelationships({ filters: { toId: entityIds }, limit: 1e4 })
+        ]);
+        allRels = [...outgoing, ...incoming];
+      } catch {
+      }
+      const relsByEntity = /* @__PURE__ */ new Map();
+      for (const rel of allRels) {
+        const fromArr = relsByEntity.get(rel.fromId);
+        if (fromArr) fromArr.push(rel);
+        else relsByEntity.set(rel.fromId, [rel]);
+        if (rel.fromId !== rel.toId) {
+          const toArr = relsByEntity.get(rel.toId);
+          if (toArr) toArr.push(rel);
+          else relsByEntity.set(rel.toId, [rel]);
+        }
+      }
+      for (const c of needsGraph) {
+        const rels = relsByEntity.get(c.entity.id) ?? [];
+        const graphResult = this.evaluateRelationshipCriteria(c.entity, rels, c.pattern.structural.relationships);
+        if (graphResult.passed) {
+          const totalMatched = c.matched.length + graphResult.matchedCriteria.length;
+          const compiled = getCompiled(c.pattern);
+          const adjustedConfidence = totalMatched / Math.max(compiled.totalCriteriaCount, 1);
+          if (adjustedConfidence >= c.pattern.minStructuralConfidence) {
+            candidates.push({
+              entity: c.entity,
+              pattern: c.pattern,
+              confidence: Math.min(adjustedConfidence, 1),
+              matchedCriteria: [...c.matched, ...graphResult.matchedCriteria]
+            });
+          }
+        }
+      }
+    } else if (needsGraph.length > 0) {
+      for (const c of needsGraph) {
+        if (c.confidence >= c.pattern.minStructuralConfidence) {
+          candidates.push({
+            entity: c.entity,
+            pattern: c.pattern,
+            confidence: c.confidence,
+            matchedCriteria: c.matched
+          });
+        }
+      }
+    }
+    log.i("STRUCTURAL_DETECTOR", "detection_complete", {
+      entities: entities.length,
+      patterns: patterns.length,
+      candidates: candidates.length
+    });
+    return candidates;
+  }
+  // ─── Metadata Evaluation (hot path — optimized) ─────────────────
+  evaluateMetadataCriteria(entity, pattern, compiled) {
+    const cacheKey = `${entity.id}::${pattern.id}`;
+    const cached = this.evalCache.get(cacheKey);
+    if (cached) return cached;
+    const result = this.evaluateMetadataUncached(entity, pattern, compiled);
+    this.evalCache.set(cacheKey, result);
+    return result;
+  }
+  // 3A: Mandatory checks separated for fast bail-out
+  evaluateRequired(entity, compiled, criteria, em) {
+    const matched = [];
+    if (compiled.entityTypeSet) {
+      matched.push(`entityType:${entity.type}`);
+    }
+    if (criteria.requiredModifiers) {
+      for (const req of criteria.requiredModifiers) {
+        if (!em.modifiers.includes(req)) return null;
+      }
+      matched.push(`modifiers:${criteria.requiredModifiers.join(",")}`);
+    }
+    if (criteria.forbiddenModifiers) {
+      for (const f of criteria.forbiddenModifiers) {
+        if (em.modifiers.includes(f)) return null;
+      }
+      matched.push("no-forbidden-modifiers");
+    }
+    if (criteria.hasNoInheritance) {
+      if (em.hasInheritance) return null;
+      matched.push("no-inheritance");
+    }
+    if (compiled.filePathNotMatchRe) {
+      if (entity.filePath && compiled.filePathNotMatchRe.test(entity.filePath)) return null;
+    }
+    if (compiled.nameNotMatchRe) {
+      if (compiled.nameNotMatchRe.test(entity.name)) return null;
+    }
+    return matched;
+  }
+  // 3A: Optional checks separated from mandatory
+  evaluateOptional(entity, compiled, criteria, em, matched) {
+    let optionalTotal = 0;
+    let optionalPassed = 0;
+    if (compiled.returnTypeMatchRe) {
+      optionalTotal++;
+      if (typeof em.returnType === "string" && compiled.returnTypeMatchRe.test(em.returnType)) {
+        optionalPassed++;
+        matched.push(`returnType:~/${criteria.returnTypeMatch}/`);
+      }
+    }
+    if (compiled.returnTypeNotMatchRe) {
+      optionalTotal++;
+      if (typeof em.returnType === "string" && !compiled.returnTypeNotMatchRe.test(em.returnType)) {
+        optionalPassed++;
+        matched.push(`returnType:!~/${criteria.returnTypeNotMatch}/`);
+      }
+    }
+    if (criteria.minParams != null) {
+      optionalTotal++;
+      if (em.params.length >= criteria.minParams) {
+        optionalPassed++;
+        matched.push(`params>=${criteria.minParams}`);
+      }
+    }
+    if (criteria.maxParams != null) {
+      optionalTotal++;
+      if (em.params.length <= criteria.maxParams) {
+        optionalPassed++;
+        matched.push(`params<=${criteria.maxParams}`);
+      }
+    }
+    if (compiled.paramTypeRequiredRe) {
+      optionalTotal++;
+      if (em.params.some((p) => p.type && compiled.paramTypeRequiredRe.test(p.type))) {
+        optionalPassed++;
+        matched.push(`paramType:${criteria.paramTypeRequired}`);
+      }
+    }
+    if (compiled.paramTypeAbsentRe) {
+      optionalTotal++;
+      if (!em.params.some((p) => p.type && compiled.paramTypeAbsentRe.test(p.type))) {
+        optionalPassed++;
+        matched.push(`paramType:!${criteria.paramTypeAbsent}`);
+      }
+    }
+    if (criteria.minCyclomatic != null) {
+      optionalTotal++;
+      if (em.metrics.cyclomaticComplexity >= criteria.minCyclomatic) {
+        optionalPassed++;
+        matched.push(`cyclomatic>=${criteria.minCyclomatic}`);
+      }
+    }
+    if (criteria.maxCyclomatic != null) {
+      optionalTotal++;
+      if (em.metrics.cyclomaticComplexity <= criteria.maxCyclomatic) {
+        optionalPassed++;
+        matched.push(`cyclomatic<=${criteria.maxCyclomatic}`);
+      }
+    }
+    if (criteria.minCognitive != null) {
+      optionalTotal++;
+      if (em.metrics.cognitiveComplexity >= criteria.minCognitive) {
+        optionalPassed++;
+        matched.push(`cognitive>=${criteria.minCognitive}`);
+      }
+    }
+    if (criteria.minNesting != null) {
+      optionalTotal++;
+      if (em.metrics.nestingDepth >= criteria.minNesting) {
+        optionalPassed++;
+        matched.push(`nesting>=${criteria.minNesting}`);
+      }
+    }
+    if (criteria.minLOC != null) {
+      optionalTotal++;
+      if (em.metrics.linesOfCode >= criteria.minLOC) {
+        optionalPassed++;
+        matched.push(`LOC>=${criteria.minLOC}`);
+      }
+    }
+    if (criteria.maxLOC != null) {
+      optionalTotal++;
+      if (em.metrics.linesOfCode <= criteria.maxLOC) {
+        optionalPassed++;
+        matched.push(`LOC<=${criteria.maxLOC}`);
+      }
+    }
+    if (criteria.hasLoops != null) {
+      optionalTotal++;
+      if (em.cf.loops > 0 === criteria.hasLoops) {
+        optionalPassed++;
+        matched.push(criteria.hasLoops ? "hasLoops" : "noLoops");
+      }
+    }
+    if (criteria.hasExceptions != null) {
+      optionalTotal++;
+      if (em.cf.exceptions > 0 === criteria.hasExceptions) {
+        optionalPassed++;
+        matched.push(criteria.hasExceptions ? "hasExceptions" : "noExceptions");
+      }
+    }
+    if (criteria.hasAwaits != null) {
+      optionalTotal++;
+      if (em.cf.awaits > 0 === criteria.hasAwaits) {
+        optionalPassed++;
+        matched.push(criteria.hasAwaits ? "hasAwaits" : "noAwaits");
+      }
+    }
+    if (criteria.minBranches != null) {
+      optionalTotal++;
+      if (em.cf.branches >= criteria.minBranches) {
+        optionalPassed++;
+        matched.push(`branches>=${criteria.minBranches}`);
+      }
+    }
+    if (criteria.minCallCount != null) {
+      optionalTotal++;
+      if (em.callNames.length >= criteria.minCallCount) {
+        optionalPassed++;
+        matched.push(`calls>=${criteria.minCallCount}`);
+      }
+    }
+    if (compiled.callsIncludeRe) {
+      for (let i = 0; i < compiled.callsIncludeRe.length; i++) {
+        optionalTotal++;
+        if (em.callNames.some((c) => compiled.callsIncludeRe[i].test(c))) {
+          optionalPassed++;
+          matched.push(`calls:~/${criteria.callsInclude[i]}/`);
+        }
+      }
+    }
+    if (compiled.callsExcludeRe) {
+      for (let i = 0; i < compiled.callsExcludeRe.length; i++) {
+        optionalTotal++;
+        if (!em.callNames.some((c) => compiled.callsExcludeRe[i].test(c))) {
+          optionalPassed++;
+          matched.push(`calls:!~/${criteria.callsExclude[i]}/`);
+        }
+      }
+    }
+    if (compiled.decoratorMatchRe) {
+      for (let i = 0; i < compiled.decoratorMatchRe.length; i++) {
+        optionalTotal++;
+        if (em.decoratorNames.some((d) => compiled.decoratorMatchRe[i].test(d))) {
+          optionalPassed++;
+          matched.push(`decorator:~/${criteria.decoratorMatch[i]}/`);
+        }
+      }
+    }
+    if (compiled.nameMatchRe) {
+      optionalTotal++;
+      if (compiled.nameMatchRe.test(entity.name)) {
+        optionalPassed++;
+        matched.push(`name:~/${criteria.nameMatch}/`);
+      }
+    }
+    if (compiled.nameNotMatchRe) {
+      matched.push(`name:!~/${criteria.nameNotMatch}/`);
+    }
+    return { optionalTotal, optionalPassed };
+  }
+  evaluateMetadataUncached(entity, pattern, compiled) {
+    const criteria = pattern.structural;
+    if (!criteria && !pattern.customDetector) {
+      return EVAL_ZERO;
+    }
+    const matched = [];
+    const em = getMeta(entity);
+    if (criteria) {
+      const requiredMatched = this.evaluateRequired(entity, compiled, criteria, em);
+      if (requiredMatched === null) return EVAL_ZERO;
+      matched.push(...requiredMatched);
+      const { optionalTotal, optionalPassed } = this.evaluateOptional(entity, compiled, criteria, em, matched);
+      const mandatoryCount = requiredMatched.length;
+      if (optionalTotal === 0) {
+        if (matched.length > 0 && !pattern.customDetector) {
+          return { confidence: 1, matchedCriteria: matched };
+        }
+      } else {
+        const conf = optionalPassed / optionalTotal;
+        if ((conf > 0 || matched.length > mandatoryCount) && !pattern.customDetector) {
+          return { confidence: conf, matchedCriteria: matched };
+        }
+      }
+    }
+    if (pattern.customDetector) {
+      const detector = detectorRegistry.get(pattern.customDetector);
+      if (detector) {
+        try {
+          const result = detector(entity);
+          if (result.match) {
+            const customMatched = result.matchedCriteria ?? [`custom:${pattern.customDetector}`];
+            const allMatched = [...matched, ...customMatched];
+            const mandatoryCount = matched.filter(
+              (m) => m.startsWith("entityType:") || m.startsWith("modifiers:") || m === "no-forbidden-modifiers"
+            ).length;
+            const hasOptionalStructural = matched.length > mandatoryCount;
+            const blended = hasOptionalStructural ? (result.confidence + matched.length / Math.max(compiled.totalCriteriaCount, 1)) / 2 : result.confidence;
+            return { confidence: blended, matchedCriteria: allMatched };
+          }
+          return EVAL_ZERO;
+        } catch (err) {
+          log.w("STRUCTURAL_DETECTOR", "custom_detector_error", {
+            detector: pattern.customDetector,
+            error: String(err)
+          });
+          return EVAL_ZERO;
+        }
+      }
+      return EVAL_ZERO;
+    }
+    if (matched.length > 0 && !criteria) {
+      return { confidence: 0.5, matchedCriteria: matched };
+    }
+    return {
+      confidence: matched.length > 0 ? matched.length / Math.max(compiled.totalCriteriaCount, 1) : 0,
+      matchedCriteria: matched
+    };
+  }
+  // ─── Relationship Evaluation ─────────────────────────────────────
+  evaluateRelationshipCriteria(entity, relationships, criteria) {
+    const matched = [];
+    for (const crit of criteria) {
+      const filtered = relationships.filter((r) => {
+        const matchesType = r.type === crit.type;
+        const matchesDirection = crit.direction === "outgoing" ? r.fromId === entity.id : r.toId === entity.id;
+        return matchesType && matchesDirection;
+      });
+      const count = filtered.length;
+      if (crit.minCount != null && count < crit.minCount) {
+        return { passed: false, matchedCriteria: matched };
+      }
+      if (crit.maxCount != null && count > crit.maxCount) {
+        return { passed: false, matchedCriteria: matched };
+      }
+      if (crit.crossFileRatio) {
+        const total = relationships.filter(
+          (r) => crit.direction === "outgoing" ? r.fromId === entity.id : r.toId === entity.id
+        ).length;
+        if (total > 0) {
+          const ratio = filtered.length / total;
+          if (crit.crossFileRatio.min != null && ratio < crit.crossFileRatio.min) {
+            return { passed: false, matchedCriteria: matched };
+          }
+          if (crit.crossFileRatio.max != null && ratio > crit.crossFileRatio.max) {
+            return { passed: false, matchedCriteria: matched };
+          }
+        }
+      }
+      matched.push(`rel:${crit.direction}:${crit.type}=${count}`);
+    }
+    return { passed: true, matchedCriteria: matched };
+  }
+};
+function countTotalCriteria(criteria) {
+  let count = 0;
+  if (criteria.entityTypes) count++;
+  if (criteria.requiredModifiers) count++;
+  if (criteria.forbiddenModifiers) count++;
+  if (criteria.returnTypeMatch) count++;
+  if (criteria.returnTypeNotMatch) count++;
+  if (criteria.minParams != null) count++;
+  if (criteria.maxParams != null) count++;
+  if (criteria.paramTypeRequired) count++;
+  if (criteria.paramTypeAbsent) count++;
+  if (criteria.minCyclomatic != null) count++;
+  if (criteria.maxCyclomatic != null) count++;
+  if (criteria.minCognitive != null) count++;
+  if (criteria.minNesting != null) count++;
+  if (criteria.minLOC != null) count++;
+  if (criteria.maxLOC != null) count++;
+  if (criteria.hasLoops != null) count++;
+  if (criteria.hasExceptions != null) count++;
+  if (criteria.hasAwaits != null) count++;
+  if (criteria.minBranches != null) count++;
+  if (criteria.minCallCount != null) count++;
+  if (criteria.callsInclude) count += criteria.callsInclude.length;
+  if (criteria.callsExclude) count += criteria.callsExclude.length;
+  if (criteria.decoratorMatch) count += criteria.decoratorMatch.length;
+  if (criteria.hasNoInheritance) count++;
+  if (criteria.filePathNotMatch) count++;
+  if (criteria.nameMatch) count++;
+  if (criteria.nameNotMatch) count++;
+  if (criteria.relationships) count += criteria.relationships.length;
+  return count;
+}
+
+// src/analysis/patterns/pattern-engine.ts
+var SEVERITY_WEIGHTS = {
+  critical: 4,
+  high: 3,
+  medium: 2,
+  low: 1,
+  info: 0
+};
+var LANGUAGE_DETECTOR_MAP = {
+  typescript: "./detectors/typescript.js",
+  javascript: "./detectors/typescript.js",
+  // JS uses same detectors as TS
+  python: "./detectors/python.js",
+  csharp: "./detectors/csharp.js",
+  java: "./detectors/java.js",
+  kotlin: "./detectors/java.js",
+  // Kotlin uses same detectors as Java
+  go: "./detectors/go.js"
+};
+var PatternEngine = class {
+  constructor(embeddingGen) {
+    this.embeddingGen = embeddingGen;
+  }
+  registry = new PatternRegistry();
+  exemplarStore = new ExemplarStore();
+  structuralDetector = new StructuralDetector();
+  semanticValidator = null;
+  initialized = false;
+  loadedDetectorModules = /* @__PURE__ */ new Set();
+  /**
+   * Lazy initialization — loads YAML rules, exemplars, and common detectors.
+   * Language-specific detectors are loaded on-demand per scan.
+   */
+  async initialize() {
+    if (this.initialized) return;
+    const baseDir = import.meta.dirname;
+    await this.registry.load(join(baseDir, "rules"));
+    await this.exemplarStore.load(join(baseDir, "exemplars"));
+    registerDetectors(common_exports);
+    this.semanticValidator = new SemanticValidator(this.exemplarStore, this.embeddingGen);
+    this.initialized = true;
+    log.i("PATTERN_ENGINE", "initialized", {
+      patterns: this.registry.size,
+      exemplars: this.exemplarStore.size
+    });
+  }
+  /**
+   * Load language-specific detectors on demand (cached — each module loaded only once)
+   */
+  async ensureDetectorsForLanguage(language) {
+    if (!language) return;
+    const modulePath = LANGUAGE_DETECTOR_MAP[language.toLowerCase()];
+    if (!modulePath || this.loadedDetectorModules.has(modulePath)) return;
+    try {
+      const detectors = await import(modulePath);
+      registerDetectors(detectors);
+      this.loadedDetectorModules.add(modulePath);
+      log.i("PATTERN_ENGINE", "loaded_detectors", { language, module: modulePath });
+    } catch {
+    }
+  }
+  /**
+   * Full scan — the main entry point
+   */
+  async scan(options, storage) {
+    await this.initialize();
+    const startMs = Date.now();
+    const {
+      filePath,
+      language,
+      category = "all",
+      tags,
+      minConfidence = 0.5,
+      severity = "all",
+      offset = 0,
+      limit = 50,
+      entityLimit = 1e4,
+      suppressPatterns
+    } = options;
+    const dbLimit = entityLimit;
+    let entities;
+    if (filePath) {
+      const isDirectory = /[\\/]$/.test(filePath) || !/\.\w+$/.test(filePath.split(/[\\/]/).pop() ?? "");
+      if (isDirectory && typeof storage.searchEntitiesInDirectory === "function") {
+        entities = await storage.searchEntitiesInDirectory(filePath);
+      } else {
+        entities = await storage.findEntities({ filters: { filePath }, limit: dbLimit });
+      }
+    } else {
+      entities = await storage.findEntities({ limit: dbLimit });
+    }
+    if (entities.length === 0) {
+      return this.emptyResult();
+    }
+    const detectedLanguage = language ?? this.detectLanguage(entities);
+    await this.ensureDetectorsForLanguage(detectedLanguage);
+    let patterns = this.registry.getPatterns({
+      language: detectedLanguage,
+      category,
+      tags,
+      enabledOnly: true
+    });
+    if (suppressPatterns?.length) {
+      const suppressSet = new Set(suppressPatterns);
+      patterns = patterns.filter((p) => !suppressSet.has(p.id));
+    }
+    if (patterns.length === 0) {
+      return this.emptyResult(entities.length);
+    }
+    const candidates = await this.structuralDetector.detect(entities, patterns, storage);
+    const patternMap = new Map(patterns.map((p) => [p.id, p]));
+    const confirmed = this.semanticValidator ? await this.semanticValidator.validate(candidates, patternMap) : candidates.map(
+      (c) => ({
+        patternId: c.pattern.id,
+        pattern: c.pattern,
+        entityId: c.entity.id,
+        entityName: c.entity.name,
+        entityType: c.entity.type,
+        filePath: c.entity.filePath,
+        line: c.entity.location?.start?.line ?? 0,
+        structuralConfidence: c.confidence,
+        semanticSimilarity: 1,
+        combinedScore: c.confidence,
+        matchedCriteria: c.matchedCriteria
+      })
+    );
+    let filtered = confirmed.filter((m) => m.combinedScore >= minConfidence);
+    if (severity !== "all") {
+      filtered = filtered.filter((m) => m.pattern.severity === severity);
+    }
+    filtered.sort((a, b) => b.combinedScore - a.combinedScore);
+    const antiPatterns = filtered.filter((m) => m.pattern.category === "anti-pattern");
+    const bestPatterns = filtered.filter((m) => m.pattern.category === "best-pattern");
+    const codeSmells = filtered.filter((m) => m.pattern.category === "code-smell");
+    const optimizations = filtered.filter((m) => m.pattern.category === "optimization");
+    const healthScore = this.computeHealthScore(antiPatterns, bestPatterns, codeSmells);
+    const topIssues = this.computeTopIssues([...antiPatterns, ...codeSmells, ...optimizations]);
+    const applyPagination = (arr) => arr.slice(offset, offset + limit);
+    const result = {
+      antiPatterns: applyPagination(antiPatterns),
+      bestPatterns: applyPagination(bestPatterns),
+      codeSmells: applyPagination(codeSmells),
+      optimizations: applyPagination(optimizations),
+      summary: {
+        totalEntitiesScanned: entities.length,
+        antiPatternCount: antiPatterns.length,
+        bestPatternCount: bestPatterns.length,
+        codeSmellCount: codeSmells.length,
+        optimizationCount: optimizations.length,
+        topIssues,
+        healthScore
+      }
+    };
+    log.i("PATTERN_ENGINE", "scan_complete", {
+      entities: entities.length,
+      patterns: patterns.length,
+      candidates: candidates.length,
+      confirmed: confirmed.length,
+      filtered: filtered.length,
+      durationMs: Date.now() - startMs
+    });
+    return result;
+  }
+  /**
+   * Check patterns for a specific entity
+   */
+  async checkEntity(entityId, storage, category = "all") {
+    await this.initialize();
+    const entity = await storage.getEntity(entityId);
+    if (!entity) return [];
+    const language = entity.language ?? entity.metadata?.language;
+    await this.ensureDetectorsForLanguage(language);
+    const patterns = this.registry.getPatterns({ language, category, enabledOnly: true });
+    const candidates = await this.structuralDetector.detect([entity], patterns, storage);
+    const patternMap = new Map(patterns.map((p) => [p.id, p]));
+    return this.semanticValidator ? await this.semanticValidator.validate(candidates, patternMap) : candidates.map(
+      (c) => ({
+        patternId: c.pattern.id,
+        pattern: c.pattern,
+        entityId: c.entity.id,
+        entityName: c.entity.name,
+        entityType: c.entity.type,
+        filePath: c.entity.filePath,
+        line: c.entity.location?.start?.line ?? 0,
+        structuralConfidence: c.confidence,
+        semanticSimilarity: 1,
+        combinedScore: c.confidence,
+        matchedCriteria: c.matchedCriteria
+      })
+    );
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────
+  detectLanguage(entities) {
+    const langCounts = /* @__PURE__ */ new Map();
+    for (const e of entities) {
+      const lang = e.language ?? e.metadata?.language;
+      if (lang) {
+        langCounts.set(lang, (langCounts.get(lang) ?? 0) + 1);
+      }
+    }
+    if (langCounts.size === 0) return void 0;
+    return [...langCounts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+  }
+  computeHealthScore(antiPatterns, bestPatterns, codeSmells) {
+    let antiWeight = 0;
+    for (const m of antiPatterns) {
+      antiWeight += SEVERITY_WEIGHTS[m.pattern.severity] ?? 1;
+    }
+    for (const m of codeSmells) {
+      antiWeight += (SEVERITY_WEIGHTS[m.pattern.severity] ?? 1) * 0.5;
+    }
+    const bestWeight = bestPatterns.length;
+    const score = Math.round(100 * (bestWeight + 1) / (bestWeight + antiWeight + 1));
+    return Math.max(0, Math.min(100, score));
+  }
+  computeTopIssues(matches) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const m of matches) {
+      const existing = counts.get(m.patternId);
+      if (existing) {
+        existing.count++;
+      } else {
+        counts.set(m.patternId, { count: 1, severity: m.pattern.severity });
+      }
+    }
+    return [...counts.entries()].map(([patternId, data]) => ({ patternId, ...data })).sort((a, b) => {
+      const severityDiff = (SEVERITY_WEIGHTS[b.severity] ?? 0) - (SEVERITY_WEIGHTS[a.severity] ?? 0);
+      return severityDiff !== 0 ? severityDiff : b.count - a.count;
+    }).slice(0, 10);
+  }
+  emptyResult(scanned = 0) {
+    return {
+      antiPatterns: [],
+      bestPatterns: [],
+      codeSmells: [],
+      optimizations: [],
+      summary: {
+        totalEntitiesScanned: scanned,
+        antiPatternCount: 0,
+        bestPatternCount: 0,
+        codeSmellCount: 0,
+        optimizationCount: 0,
+        topIssues: [],
+        healthScore: 100
+      }
+    };
+  }
+};
+
+// src/analysis/patterns/pattern-formatter.ts
+var PatternFormatter = class _PatternFormatter {
+  /**
+   * Format scan result based on output format
+   */
+  static format(result, format = "summary") {
+    if (format === "json") {
+      return JSON.stringify(result, null, 2);
+    }
+    if (format === "detailed") {
+      return _PatternFormatter.formatDetailed(result);
+    }
+    return _PatternFormatter.formatSummary(result);
+  }
+  static formatSummary(result) {
+    const { summary } = result;
+    const lines = [];
+    lines.push(`## Pattern Scan Summary`);
+    lines.push(`- Entities scanned: ${summary.totalEntitiesScanned}`);
+    lines.push(`- Health score: ${summary.healthScore}/100`);
+    lines.push(``);
+    if (summary.antiPatternCount > 0) {
+      lines.push(`### Anti-patterns: ${summary.antiPatternCount}`);
+      for (const m of result.antiPatterns.slice(0, 10)) {
+        lines.push(
+          `  - **${m.pattern.name}** in \`${m.entityName}\` (${m.filePath}:${m.line}) \u2014 score: ${m.combinedScore.toFixed(2)}`
+        );
+      }
+      lines.push(``);
+    }
+    if (summary.codeSmellCount > 0) {
+      lines.push(`### Code smells: ${summary.codeSmellCount}`);
+      for (const m of result.codeSmells.slice(0, 10)) {
+        lines.push(
+          `  - **${m.pattern.name}** in \`${m.entityName}\` (${m.filePath}:${m.line}) \u2014 score: ${m.combinedScore.toFixed(2)}`
+        );
+      }
+      lines.push(``);
+    }
+    if (summary.optimizationCount > 0) {
+      lines.push(`### Optimizations: ${summary.optimizationCount}`);
+      for (const m of result.optimizations.slice(0, 10)) {
+        const bigO = m.pattern.bigO ? ` [${m.pattern.bigO.before} \u2192 ${m.pattern.bigO.after}]` : "";
+        const bench = m.pattern.benchmark ? ` (${m.pattern.benchmark})` : "";
+        lines.push(`  - **${m.pattern.name}**${bigO}${bench} in \`${m.entityName}\` (${m.filePath}:${m.line})`);
+      }
+      lines.push(``);
+    }
+    if (summary.bestPatternCount > 0) {
+      lines.push(`### Best patterns: ${summary.bestPatternCount}`);
+      for (const m of result.bestPatterns.slice(0, 5)) {
+        lines.push(`  - **${m.pattern.name}** in \`${m.entityName}\` (${m.filePath}:${m.line})`);
+      }
+      lines.push(``);
+    }
+    if (summary.topIssues.length > 0) {
+      lines.push(`### Top Issues`);
+      for (const issue of summary.topIssues.slice(0, 5)) {
+        lines.push(`  - \`${issue.patternId}\` \u2014 ${issue.count} occurrence(s), severity: ${issue.severity}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  static formatDetailed(result) {
+    const all = [
+      ...result.antiPatterns,
+      ...result.codeSmells,
+      ...result.optimizations,
+      ...result.bestPatterns
+    ];
+    const lines = [];
+    lines.push(`## Pattern Scan \u2014 Detailed (${all.length} matches, health: ${result.summary.healthScore}/100)`);
+    lines.push(``);
+    for (const m of all) {
+      const icon = m.pattern.category === "anti-pattern" ? "\u{1F534}" : m.pattern.category === "code-smell" ? "\u{1F7E1}" : m.pattern.category === "optimization" ? "\u26A1" : "\u{1F7E2}";
+      lines.push(`### ${icon} ${m.pattern.name} [\`${m.patternId}\`]`);
+      lines.push(`- **Category**: ${m.pattern.category} | **Severity**: ${m.pattern.severity}`);
+      lines.push(`- **Entity**: \`${m.entityName}\` (${m.entityType}) at ${m.filePath}:${m.line}`);
+      lines.push(
+        `- **Score**: combined=${m.combinedScore.toFixed(2)}, structural=${m.structuralConfidence.toFixed(2)}, semantic=${m.semanticSimilarity.toFixed(2)}`
+      );
+      lines.push(`- **Description**: ${m.pattern.description}`);
+      lines.push(`- **Suggestion**: ${m.pattern.suggestion}`);
+      if (m.pattern.bigO) {
+        lines.push(`- **Complexity**: ${m.pattern.bigO.before} \u2192 ${m.pattern.bigO.after}`);
+      }
+      if (m.pattern.benchmark) {
+        lines.push(`- **Benchmark**: ${m.pattern.benchmark}`);
+      }
+      if (m.closestExemplar) {
+        lines.push(
+          `- **Closest exemplar**: ${m.closestExemplar.id} (similarity: ${m.closestExemplar.similarity.toFixed(2)}) \u2014 ${m.closestExemplar.description}`
+        );
+      }
+      if (m.matchedCriteria.length > 0) {
+        lines.push(`- **Matched criteria**: ${m.matchedCriteria.join(", ")}`);
+      }
+      lines.push(``);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format for JSON API response (used by MCP handlers)
+   */
+  static toJSON(result) {
+    return {
+      summary: result.summary,
+      antiPatterns: result.antiPatterns.map(_PatternFormatter.matchToJSON),
+      bestPatterns: result.bestPatterns.map(_PatternFormatter.matchToJSON),
+      codeSmells: result.codeSmells.map(_PatternFormatter.matchToJSON),
+      optimizations: result.optimizations.map(_PatternFormatter.matchToJSON)
+    };
+  }
+  static matchToJSON(m) {
+    return {
+      patternId: m.patternId,
+      category: m.pattern.category,
+      severity: m.pattern.severity,
+      name: m.pattern.name,
+      description: m.pattern.description,
+      suggestion: m.pattern.suggestion,
+      bigO: m.pattern.bigO,
+      benchmark: m.pattern.benchmark,
+      entityId: m.entityId,
+      entityName: m.entityName,
+      entityType: m.entityType,
+      filePath: m.filePath,
+      line: m.line,
+      combinedScore: Number(m.combinedScore.toFixed(3)),
+      structuralConfidence: Number(m.structuralConfidence.toFixed(3)),
+      semanticSimilarity: Number(m.semanticSimilarity.toFixed(3)),
+      matchedCriteria: m.matchedCriteria,
+      closestExemplar: m.closestExemplar
+    };
+  }
+};
+
+// src/tools/handlers/pattern-tool-handlers.ts
+init_logging();
+var sharedEngine = null;
+function getEngine(embeddingGen) {
+  if (!sharedEngine) {
+    sharedEngine = new PatternEngine(embeddingGen);
+  }
+  return sharedEngine;
+}
+var DetectPatternsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return DetectPatternsSchema.parse(args);
+  }
+  async execute(args) {
+    try {
+      const storage = await this.ensureGraphStorageForProject(args.projectPath);
+      let embeddingGen;
+      try {
+        const semanticAgent = await this.context.getSemanticAgent();
+        embeddingGen = semanticAgent.embeddingGenerator ?? semanticAgent.getEmbeddingGenerator?.();
+      } catch {
+      }
+      const engine = getEngine(embeddingGen);
+      const options = {
+        projectPath: this.resolveProjectPath(args),
+        filePath: args.filePath,
+        language: args.language,
+        category: args.category,
+        tags: args.tags,
+        minConfidence: args.minConfidence,
+        severity: args.severity === "all" ? "all" : args.severity,
+        offset: args.offset,
+        limit: args.limit,
+        entityLimit: args.entityLimit,
+        suppressPatterns: args.suppressPatterns
+      };
+      const result = await engine.scan(options, storage);
+      const nextSteps = [];
+      const allMatches = [
+        ...result.antiPatterns,
+        ...result.bestPatterns,
+        ...result.codeSmells,
+        ...result.optimizations
+      ];
+      const hasSecurityPatterns = allMatches.some(
+        (m) => m.pattern.tags.some((t) => /security|injection|xss|auth/i.test(t))
+      );
+      if (hasSecurityPatterns) {
+        nextSteps.push("taint_analysis() \u2014 deep security analysis of detected vulnerable patterns");
+      }
+      nextSteps.push("graph_metrics({metric:'pagerank'}) \u2014 rank affected entities by importance");
+      let output;
+      if (args.format === "json") {
+        const json = PatternFormatter.toJSON(result);
+        json["nextSteps"] = nextSteps;
+        output = JSON.stringify(json, null, 2);
+      } else if (args.format === "detailed") {
+        output = PatternFormatter.format(result, "detailed");
+        output += `
+
+---
+Next steps:
+${nextSteps.map((s) => `- ${s}`).join("\n")}`;
+      } else {
+        output = PatternFormatter.format(result, "summary");
+        output += `
+
+---
+Next steps:
+${nextSteps.map((s) => `- ${s}`).join("\n")}`;
+      }
+      return {
+        content: [{ type: "text", text: output }]
+      };
+    } catch (err) {
+      const error = toError(err);
+      log.e("DETECT_PATTERNS", "scan_error", { error: error.message });
+      return {
+        content: [{ type: "text", text: `Error: ${error.message}` }]
+      };
+    }
+  }
+};
+var CheckEntityPatternsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CheckEntityPatternsSchema.parse(args);
+  }
+  async execute(args) {
+    try {
+      const storage = await this.ensureGraphStorageForProject(args.projectPath);
+      let embeddingGen;
+      try {
+        const semanticAgent = await this.context.getSemanticAgent();
+        embeddingGen = semanticAgent.embeddingGenerator ?? semanticAgent.getEmbeddingGenerator?.();
+      } catch {
+      }
+      const engine = getEngine(embeddingGen);
+      const matches = await engine.checkEntity(args.entityId, storage, args.category);
+      if (matches.length === 0) {
+        return {
+          content: [{ type: "text", text: `No pattern matches found for entity ${args.entityId}` }]
+        };
+      }
+      const output = {
+        entityId: args.entityId,
+        matchCount: matches.length,
+        matches: matches.map((m) => ({
+          patternId: m.patternId,
+          category: m.pattern.category,
+          severity: m.pattern.severity,
+          name: m.pattern.name,
+          description: m.pattern.description,
+          suggestion: m.pattern.suggestion,
+          bigO: m.pattern.bigO,
+          benchmark: m.pattern.benchmark,
+          combinedScore: Number(m.combinedScore.toFixed(3)),
+          structuralConfidence: Number(m.structuralConfidence.toFixed(3)),
+          semanticSimilarity: Number(m.semanticSimilarity.toFixed(3)),
+          matchedCriteria: m.matchedCriteria,
+          closestExemplar: m.closestExemplar
+        }))
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
+      };
+    } catch (err) {
+      const error = toError(err);
+      log.e("CHECK_ENTITY_PATTERNS", "check_error", { error: error.message });
+      return {
+        content: [{ type: "text", text: `Error: ${error.message}` }]
+      };
+    }
+  }
+};
+
+export { CheckEntityPatternsToolHandler, DetectPatternsToolHandler };
+//# sourceMappingURL=pattern-tool-handlers-L62W3CXR.js.map
+//# sourceMappingURL=pattern-tool-handlers-L62W3CXR.js.map