@titan-design/style-analyzer 0.0.0

package/dist/index.js

@@ -0,0 +1,2218 @@
+// src/index.ts
+import {
+  shouldIncludeFile,
+  getLanguageFromPath,
+  parseFile,
+  getSupportedLanguages
+} from "@titan-design/code-parser";
+
+// src/extractors/naming.ts
+var NAMING_PATTERNS = {
+  camelCase: /^[a-z][a-zA-Z0-9]*$/,
+  PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
+  snake_case: /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/,
+  SCREAMING_SNAKE: /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)+$/,
+  "kebab-case": /^[a-z][a-z0-9]*(-[a-z0-9]+)+$/
+};
+var BOOLEAN_PREFIXES = /^(is|has|should|can|will|did|was)[A-Z_]/;
+var PYTHON_BOOLEAN_PREFIXES = /^(is|has|should|can|will|did|was)_/;
+function detectConvention(name) {
+  for (const [convention, pattern] of Object.entries(NAMING_PATTERNS)) {
+    if (pattern.test(name)) return convention;
+  }
+  if (/^[a-z][a-z0-9]*$/.test(name)) return "camelCase";
+  return null;
+}
+function detectBooleanPrefix(name, language) {
+  const pattern = language === "python" ? PYTHON_BOOLEAN_PREFIXES : BOOLEAN_PREFIXES;
+  const match = name.match(pattern);
+  return match ? match[1] : null;
+}
+var NamingExtractor = class {
+  name = "naming";
+  extract(file) {
+    const observations = [];
+    const visit = (node) => {
+      this.processNode(node, file, observations);
+      for (const child of node.children) {
+        visit(child);
+      }
+    };
+    visit(file.tree.rootNode);
+    return observations;
+  }
+  processNode(node, file, observations) {
+    switch (file.language) {
+      case "typescript":
+      case "tsx":
+        this.processTypeScriptNode(node, file, observations);
+        break;
+      case "python":
+        this.processPythonNode(node, file, observations);
+        break;
+    }
+  }
+  processTypeScriptNode(node, file, observations) {
+    switch (node.type) {
+      case "variable_declarator":
+        this.processTypeScriptVariable(node, file, observations);
+        break;
+      case "function_declaration":
+        this.observeDeclarationName(node, "naming.function", file, observations);
+        break;
+      case "interface_declaration":
+      case "type_alias_declaration":
+        this.observeDeclarationName(node, "naming.type", file, observations);
+        break;
+      case "enum_declaration":
+        this.observeDeclarationName(node, "naming.enum", file, observations);
+        break;
+      case "class_declaration":
+        if (this.observeDeclarationName(node, "naming.type", file, observations)) {
+          this.detectPrivateMembers(node, file, observations);
+        }
+        break;
+      case "required_parameter":
+      case "optional_parameter":
+        this.processTypeScriptParameter(node, file, observations);
+        break;
+    }
+  }
+  processTypeScriptVariable(node, file, observations) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode || nameNode.type !== "identifier") return;
+    const name = nameNode.text;
+    const declKind = node.parent?.type === "lexical_declaration" ? node.parent.children[0]?.text : null;
+    if (declKind === "const" && NAMING_PATTERNS.SCREAMING_SNAKE.test(name)) {
+      this.addObservation(observations, "naming.constant", "SCREAMING_SNAKE", file, node);
+      return;
+    }
+    this.observeVariable(name, node, file, observations);
+  }
+  processTypeScriptParameter(node, file, observations) {
+    const nameNode = node.childForFieldName("pattern") ?? node.childForFieldName("name");
+    if (!nameNode || nameNode.type !== "identifier") return;
+    if (nameNode.text === "this") return;
+    const convention = detectConvention(nameNode.text);
+    if (convention) {
+      this.addObservation(observations, "naming.parameter", convention, file, node);
+    }
+  }
+  processPythonNode(node, file, observations) {
+    switch (node.type) {
+      case "assignment":
+        this.processPythonAssignment(node, file, observations);
+        break;
+      case "function_definition": {
+        const nameNode = node.childForFieldName("name");
+        if (!nameNode) break;
+        if (nameNode.text.startsWith("__") && nameNode.text.endsWith("__")) break;
+        this.observeDeclarationName(node, "naming.function", file, observations);
+        break;
+      }
+      case "class_definition":
+        this.observeDeclarationName(node, "naming.type", file, observations);
+        break;
+      case "parameters":
+        this.processPythonParameters(node, file, observations);
+        break;
+    }
+  }
+  processPythonAssignment(node, file, observations) {
+    const left = node.childForFieldName("left");
+    if (!left || left.type !== "identifier") return;
+    const name = left.text;
+    if (node.parent?.type === "module" && NAMING_PATTERNS.SCREAMING_SNAKE.test(name)) {
+      this.addObservation(observations, "naming.constant", "SCREAMING_SNAKE", file, node);
+      return;
+    }
+    this.observeVariable(name, node, file, observations);
+  }
+  processPythonParameters(node, file, observations) {
+    for (const child of node.children) {
+      if (child.type === "identifier" && child.text !== "self" && child.text !== "cls") {
+        const convention = detectConvention(child.text);
+        if (convention) {
+          this.addObservation(observations, "naming.parameter", convention, file, child);
+        }
+      }
+      if (child.type === "typed_parameter") {
+        const paramName = child.childForFieldName("name") ?? child.children[0];
+        if (paramName && paramName.type === "identifier" && paramName.text !== "self") {
+          const convention = detectConvention(paramName.text);
+          if (convention) {
+            this.addObservation(observations, "naming.parameter", convention, file, child);
+          }
+        }
+      }
+    }
+  }
+  observeVariable(name, node, file, observations) {
+    const prefix = detectBooleanPrefix(name, file.language);
+    if (prefix) {
+      this.addObservation(observations, "naming.boolean", prefix, file, node);
+    }
+    const convention = detectConvention(name);
+    if (convention) {
+      this.addObservation(observations, "naming.variable", convention, file, node);
+    }
+  }
+  // Returns whether the node had a name, because a nameless class skips its private-member scan.
+  observeDeclarationName(node, type, file, observations) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return false;
+    const convention = detectConvention(nameNode.text);
+    if (convention) {
+      this.addObservation(observations, type, convention, file, node);
+    }
+    return true;
+  }
+  detectPrivateMembers(classNode, file, observations) {
+    const body = classNode.childForFieldName("body");
+    if (!body) return;
+    for (const member of body.children) {
+      if (member.type === "public_field_definition") {
+        const nameNode = member.childForFieldName("name");
+        if (!nameNode) continue;
+        const name = nameNode.text;
+        if (name.startsWith("#")) {
+          this.addObservation(observations, "naming.private-member", "hash-prefix", file, member);
+        } else if (name.startsWith("_") && !name.startsWith("__")) {
+          this.addObservation(observations, "naming.private-member", "underscore-prefix", file, member);
+        }
+      }
+    }
+  }
+  addObservation(observations, type, value, file, node) {
+    observations.push({
+      type,
+      category: "naming",
+      value,
+      file: file.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+};
+
+// src/extractors/structure.ts
+var PYTHON_BUILTINS = /* @__PURE__ */ new Set([
+  "os",
+  "sys",
+  "re",
+  "json",
+  "math",
+  "time",
+  "datetime",
+  "pathlib",
+  "collections",
+  "itertools",
+  "functools",
+  "typing",
+  "io",
+  "abc",
+  "dataclasses",
+  "enum",
+  "logging",
+  "unittest",
+  "hashlib",
+  "subprocess",
+  "argparse",
+  "copy",
+  "glob",
+  "shutil",
+  "tempfile",
+  "textwrap",
+  "contextlib",
+  "operator",
+  "string",
+  "struct",
+  "csv",
+  "xml"
+]);
+function classifyImportSource(source, language) {
+  if (language === "python") {
+    if (source.startsWith(".")) return "relative";
+    const topModule = source.split(".")[0];
+    if (PYTHON_BUILTINS.has(topModule)) return "builtin";
+    return "external";
+  }
+  if (source.startsWith("node:")) return "builtin";
+  if (source.startsWith(".") || source.startsWith("..")) return "relative";
+  if (source.startsWith("@")) {
+    const scope = source.split("/")[0];
+    if (["@app", "@lib", "@src", "@internal", "@modules"].includes(scope)) {
+      return "internal";
+    }
+  }
+  return "external";
+}
+var EXPORT_DECLARATION_TYPES = [
+  "function_declaration",
+  "class_declaration",
+  "lexical_declaration",
+  "interface_declaration",
+  "type_alias_declaration",
+  "enum_declaration"
+];
+function isBarrelFile(root) {
+  let exportFromCount = 0;
+  let otherStatements = 0;
+  for (const child of root.children) {
+    if (child.type === "export_statement") {
+      const source = child.childForFieldName("source");
+      if (source) {
+        exportFromCount++;
+      } else {
+        otherStatements++;
+      }
+    } else if (child.isNamed && child.type !== "comment") {
+      otherStatements++;
+    }
+  }
+  return exportFromCount > 0 && otherStatements <= 1;
+}
+var StructureExtractor = class {
+  name = "structure";
+  extract(file) {
+    const observations = [];
+    const root = file.tree.rootNode;
+    this.extractImports(root, file, observations);
+    this.extractExports(root, file, observations);
+    this.detectBarrelFile(root, file, observations);
+    return observations;
+  }
+  extractImports(root, file, observations) {
+    const groupSequence = [];
+    for (const child of root.children) {
+      const source = this.importSource(child, file.language);
+      if (source) {
+        const group = classifyImportSource(source, file.language);
+        groupSequence.push(group);
+        observations.push({
+          type: "structure.import-group",
+          category: "structure",
+          value: group,
+          file: file.filePath,
+          line: child.startPosition.row + 1,
+          metadata: { source }
+        });
+      }
+    }
+    this.addImportOrder(groupSequence, file, observations);
+  }
+  addImportOrder(groupSequence, file, observations) {
+    const uniqueOrder = [...new Set(groupSequence)];
+    if (uniqueOrder.length > 0) {
+      observations.push({
+        type: "structure.import-order",
+        category: "structure",
+        value: JSON.stringify(uniqueOrder),
+        file: file.filePath,
+        line: 1,
+        metadata: { groupCount: uniqueOrder.length }
+      });
+    }
+  }
+  importSource(child, language) {
+    let source = null;
+    if (language === "python") {
+      if (child.type === "import_statement") {
+        const nameNode = child.childForFieldName("name");
+        source = nameNode?.text ?? null;
+      } else if (child.type === "import_from_statement") {
+        const moduleNode = child.childForFieldName("module_name");
+        const dots = child.children.filter((c) => c.type === "." || c.type === "relative_import").map((c) => c.text).join("");
+        source = dots + (moduleNode?.text ?? "");
+      }
+    } else {
+      if (child.type === "import_statement") {
+        const sourceNode = child.childForFieldName("source");
+        source = sourceNode?.text?.replace(/['"]/g, "") ?? null;
+      }
+    }
+    return source;
+  }
+  extractExports(root, file, observations) {
+    if (file.language === "python") return;
+    for (const child of root.children) {
+      if (child.type === "export_statement") {
+        this.processExport(child, file, observations);
+      }
+    }
+  }
+  processExport(child, file, observations) {
+    const isDefault = child.children.some((c) => c.type === "default");
+    const style = isDefault ? "default" : "named";
+    observations.push({
+      type: "structure.export-style",
+      category: "structure",
+      value: style,
+      file: file.filePath,
+      line: child.startPosition.row + 1
+    });
+    const proximity = this.exportProximity(child, isDefault);
+    if (proximity) {
+      observations.push({
+        type: "structure.export-proximity",
+        category: "structure",
+        value: proximity,
+        file: file.filePath,
+        line: child.startPosition.row + 1
+      });
+    }
+  }
+  exportProximity(child, isDefault) {
+    const hasDeclaration = child.children.some(
+      (c) => EXPORT_DECLARATION_TYPES.includes(c.type)
+    );
+    const isReExport = child.childForFieldName("source") !== null;
+    if (hasDeclaration || isDefault) return "inline";
+    if (!isReExport) return "trailing";
+    return null;
+  }
+  detectBarrelFile(root, file, observations) {
+    if (file.language === "python") return;
+    if (isBarrelFile(root)) {
+      observations.push({
+        type: "structure.barrel-file",
+        category: "structure",
+        value: true,
+        file: file.filePath,
+        line: 1
+      });
+    }
+  }
+};
+
+// src/extractors/control-flow.ts
+var ARRAY_METHODS = /* @__PURE__ */ new Set([
+  "map",
+  "filter",
+  "reduce",
+  "forEach",
+  "find",
+  "some",
+  "every",
+  "flatMap",
+  "findIndex"
+]);
+var ControlFlowExtractor = class {
+  name = "control-flow";
+  extract(file) {
+    const observations = [];
+    this.walk(file.tree.rootNode, file, observations);
+    return observations;
+  }
+  walk(node, file, observations) {
+    this.processNode(node, file, observations);
+    for (const child of node.children) {
+      this.walk(child, file, observations);
+    }
+  }
+  processNode(node, file, observations) {
+    this.processBranch(node, file, observations);
+    this.processLoop(node, file, observations);
+    this.processCall(node, file, observations);
+  }
+  processBranch(node, file, observations) {
+    if (node.type === "ternary_expression" || node.type === "conditional_expression") {
+      this.emit(observations, "control-flow.ternary", true, file, node);
+    }
+    if (node.type === "if_statement") {
+      this.emit(observations, "control-flow.if-else", true, file, node);
+      this.detectGuardClause(node, file, observations);
+      this.detectElseAfterReturn(node, file, observations);
+    }
+  }
+  processLoop(node, file, observations) {
+    if (node.type === "for_statement" && file.language !== "python") {
+      this.emit(observations, "control-flow.for-loop", true, file, node);
+    }
+    if (node.type === "for_in_statement") {
+      const isForOf = node.children.some((c) => c.type === "of");
+      const loopType = isForOf ? "control-flow.for-of" : "control-flow.for-in";
+      this.emit(observations, loopType, true, file, node);
+    }
+    if (node.type === "for_statement" && file.language === "python") {
+      this.emit(observations, "control-flow.for-loop", true, file, node);
+    }
+    if (node.type === "list_comprehension" || node.type === "set_comprehension" || node.type === "dictionary_comprehension" || node.type === "generator_expression") {
+      this.emit(observations, "control-flow.array-method", true, file, node);
+    }
+  }
+  processCall(node, file, observations) {
+    if (node.type === "call_expression") {
+      const fn = node.childForFieldName("function");
+      if (fn?.type === "member_expression") {
+        this.processMemberCall(fn, node, file, observations);
+      }
+    }
+    if (node.type === "await_expression") {
+      this.emit(observations, "control-flow.async-await", true, file, node);
+    }
+  }
+  processMemberCall(fn, node, file, observations) {
+    const property = fn.childForFieldName("property");
+    if (property) {
+      const methodName = property.text;
+      if (ARRAY_METHODS.has(methodName)) {
+        this.emit(
+          observations,
+          "control-flow.array-method",
+          methodName,
+          file,
+          node
+        );
+      }
+      if (methodName === "then") {
+        this.emit(
+          observations,
+          "control-flow.promise-then",
+          true,
+          file,
+          node
+        );
+      }
+    }
+  }
+  detectGuardClause(node, file, observations) {
+    const parent = node.parent;
+    if (!parent) return;
+    if (!this.isFunctionBody(parent)) return;
+    const siblings = parent.children.filter(
+      (c) => c.type !== "comment" && c.type !== "{" && c.type !== "}"
+    );
+    const nodeIndex = siblings.indexOf(node);
+    if (nodeIndex > 2) return;
+    const consequent = node.childForFieldName("consequence") ?? node.childForFieldName("body");
+    if (!consequent) return;
+    const hasReturn = this.containsReturn(consequent);
+    const hasElse = node.childForFieldName("alternative") !== null;
+    if (hasReturn && !hasElse) {
+      this.emit(observations, "control-flow.guard-clause", true, file, node);
+    }
+  }
+  isFunctionBody(parent) {
+    const isFunctionBody = parent.type === "statement_block" && (parent.parent?.type === "function_declaration" || parent.parent?.type === "method_definition" || parent.parent?.type === "arrow_function");
+    const isPythonFunctionBody = parent.type === "block" && parent.parent?.type === "function_definition";
+    return isFunctionBody || isPythonFunctionBody;
+  }
+  detectElseAfterReturn(node, file, observations) {
+    const consequent = node.childForFieldName("consequence") ?? node.childForFieldName("body");
+    const alternative = node.childForFieldName("alternative");
+    if (!consequent || !alternative) return;
+    if (this.containsReturn(consequent)) {
+      this.emit(
+        observations,
+        "control-flow.else-after-return",
+        true,
+        file,
+        node
+      );
+    }
+  }
+  containsReturn(node) {
+    if (node.type === "return_statement") return true;
+    for (const child of node.children) {
+      if (child.type === "return_statement") return true;
+    }
+    return false;
+  }
+  emit(observations, type, value, file, node) {
+    observations.push({
+      type,
+      category: "control-flow",
+      value,
+      file: file.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+};
+
+// src/extractors/documentation.ts
+var JSDOC_TAG_PATTERN = /@(param|returns?|throws?|example|deprecated|see|since|type|typedef|template|callback|async)\b/g;
+var PYTHON_DOC_TAG_PATTERN = /^[ \t]*(Args|Returns?|Raises?|Yields?|Note|Notes|Example|Attributes|Todo|References):/gm;
+var DocumentationExtractor = class {
+  name = "documentation";
+  extract(file) {
+    const observations = [];
+    this.walkDeclarations(file.tree.rootNode, file, observations);
+    this.walkForComments(file.tree.rootNode, file, observations);
+    return observations;
+  }
+  walkDeclarations(node, file, observations) {
+    for (const child of node.children) {
+      if (this.isDeclaration(child, file.language)) {
+        this.processDeclaration(child, file, observations);
+      }
+      if (child.type === "class_declaration" || child.type === "class_definition" || child.type === "class_body" || child.type === "block") {
+        this.walkDeclarations(child, file, observations);
+      }
+      if (child.type === "export_statement") {
+        this.walkDeclarations(child, file, observations);
+      }
+    }
+  }
+  isDeclaration(node, language) {
+    if (language === "python") {
+      return node.type === "function_definition" || node.type === "class_definition";
+    }
+    return node.type === "function_declaration" || node.type === "method_definition" || node.type === "class_declaration" || node.type === "interface_declaration" || node.type === "type_alias_declaration";
+  }
+  processDeclaration(node, file, observations) {
+    const isExported = this.isExported(node, file.language);
+    const hasDoc = this.hasLeadingDoc(node, file.language);
+    this.emit(observations, "documentation.jsdoc-presence", hasDoc, file, node);
+    const coverageType = isExported ? "documentation.public-coverage" : "documentation.private-coverage";
+    this.emit(observations, coverageType, hasDoc, file, node);
+    if (hasDoc) {
+      this.extractTags(node, file, observations);
+    }
+  }
+  hasLeadingDoc(node, language) {
+    if (language === "python") {
+      return this.hasPythonDocstring(node);
+    }
+    return this.hasJSDoc(node);
+  }
+  hasJSDoc(node) {
+    const prev = node.previousSibling;
+    if (prev?.type === "comment" && prev.text.startsWith("/**")) {
+      return true;
+    }
+    if (node.parent?.type === "export_statement") {
+      const exportPrev = node.parent.previousSibling;
+      if (exportPrev?.type === "comment" && exportPrev.text.startsWith("/**")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  hasPythonDocstring(node) {
+    const body = node.childForFieldName("body");
+    if (!body) return false;
+    const firstStatement = body.children.find(
+      (c) => c.type !== "comment" && c.type !== "newline"
+    );
+    if (!firstStatement) return false;
+    if (firstStatement.type === "expression_statement") {
+      const expr = firstStatement.children[0];
+      return expr?.type === "string" || expr?.type === "concatenated_string";
+    }
+    return false;
+  }
+  extractTags(node, file, observations) {
+    if (file.language === "python") {
+      this.extractPythonDocTags(node, file, observations);
+      return;
+    }
+    const commentNode = this.getLeadingComment(node);
+    if (!commentNode) return;
+    const text = commentNode.text;
+    const tagMatches = text.matchAll(JSDOC_TAG_PATTERN);
+    const seenTags = /* @__PURE__ */ new Set();
+    for (const match of tagMatches) {
+      const tag = `@${match[1]}`;
+      const normalized = tag.replace(/^@return$/, "@returns").replace(/^@throw$/, "@throws");
+      if (seenTags.has(normalized)) continue;
+      seenTags.add(normalized);
+      this.emit(observations, "documentation.jsdoc-tag", normalized, file, commentNode);
+    }
+  }
+  extractPythonDocTags(node, file, observations) {
+    const body = node.childForFieldName("body");
+    if (!body) return;
+    const firstStatement = body.children.find(
+      (c) => c.type === "expression_statement"
+    );
+    if (!firstStatement) return;
+    const expr = firstStatement.children[0];
+    if (!expr) return;
+    const text = expr.text;
+    const tagMatches = text.matchAll(PYTHON_DOC_TAG_PATTERN);
+    const seenTags = /* @__PURE__ */ new Set();
+    for (const match of tagMatches) {
+      const tag = match[1];
+      if (seenTags.has(tag)) continue;
+      seenTags.add(tag);
+      this.emit(observations, "documentation.jsdoc-tag", tag, file, expr);
+    }
+  }
+  walkForComments(node, file, observations) {
+    if (node.type === "comment") {
+      if (!node.text.startsWith("/**")) {
+        this.emit(observations, "documentation.inline-comment", true, file, node);
+        const placement = this.getCommentPlacement(node);
+        this.emit(observations, "documentation.comment-placement", placement, file, node);
+      }
+    }
+    for (const child of node.children) {
+      this.walkForComments(child, file, observations);
+    }
+  }
+  getCommentPlacement(node) {
+    const prev = node.previousSibling;
+    if (prev && prev.endPosition.row === node.startPosition.row) {
+      return "trailing";
+    }
+    return "leading";
+  }
+  isExported(node, language) {
+    if (language === "python") {
+      const nameNode = node.childForFieldName("name");
+      return node.parent?.type === "module" && !!nameNode && !nameNode.text.startsWith("_");
+    }
+    return node.parent?.type === "export_statement";
+  }
+  getLeadingComment(node) {
+    const prev = node.previousSibling;
+    if (prev?.type === "comment" && prev.text.startsWith("/**")) {
+      return prev;
+    }
+    if (node.parent?.type === "export_statement") {
+      const exportPrev = node.parent.previousSibling;
+      if (exportPrev?.type === "comment" && exportPrev.text.startsWith("/**")) {
+        return exportPrev;
+      }
+    }
+    return null;
+  }
+  emit(observations, type, value, file, node) {
+    observations.push({
+      type,
+      category: "documentation",
+      value,
+      file: file.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+};
+
+// src/extractors/error-handling.ts
+var RESULT_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "Result",
+  "Either",
+  "Ok",
+  "Err",
+  "Success",
+  "Failure"
+]);
+var GENERIC_CATCH_TYPES = /* @__PURE__ */ new Set([
+  "Error",
+  "Exception",
+  "unknown"
+]);
+var ErrorHandlingExtractor = class {
+  name = "error-handling";
+  extract(file) {
+    const observations = [];
+    this.walk(file.tree.rootNode, file, observations);
+    return observations;
+  }
+  walk(node, file, observations) {
+    this.processNode(node, file, observations);
+    for (const child of node.children) {
+      this.walk(child, file, observations);
+    }
+  }
+  processNode(node, file, observations) {
+    this.processDeclaration(node, file, observations);
+    this.processFunctionCheck(node, file, observations);
+  }
+  processDeclaration(node, file, observations) {
+    if (node.type === "try_statement") {
+      this.emit(observations, "error-handling.try-catch", true, file, node);
+      this.analyzeCatchClauses(node, file, observations);
+    }
+    if (node.type === "class_declaration" || node.type === "class_definition") {
+      this.detectCustomErrorClass(node, file, observations);
+    }
+    if (node.type === "type_alias_declaration" && (file.language === "typescript" || file.language === "tsx")) {
+      this.detectResultType(node, file, observations);
+    }
+  }
+  processFunctionCheck(node, file, observations) {
+    if (node.type === "function_declaration" || node.type === "method_definition") {
+      this.detectResultReturnType(node, file, observations);
+    }
+    if (node.type === "function_declaration") {
+      this.detectAssertNever(node, file, observations);
+    }
+    if (node.type === "switch_statement") {
+      this.detectExhaustiveSwitch(node, file, observations);
+    }
+  }
+  analyzeCatchClauses(tryNode, file, observations) {
+    for (const child of tryNode.children) {
+      if (child.type === "catch_clause") {
+        const body = child.childForFieldName("body");
+        if (body && this.hasInstanceofCheck(body)) {
+          this.emit(observations, "error-handling.catch-specificity", "specific", file, child);
+        } else {
+          this.emit(observations, "error-handling.catch-specificity", "generic", file, child);
+        }
+      }
+      if (child.type === "except_clause") {
+        const typeNode = child.children.find(
+          (c) => c.type === "identifier" || c.type === "attribute"
+        );
+        if (typeNode && !GENERIC_CATCH_TYPES.has(typeNode.text)) {
+          this.emit(observations, "error-handling.catch-specificity", "specific", file, child);
+        } else {
+          this.emit(observations, "error-handling.catch-specificity", "generic", file, child);
+        }
+      }
+    }
+  }
+  hasInstanceofCheck(body) {
+    return body.text.includes("instanceof");
+  }
+  detectCustomErrorClass(node, file, observations) {
+    if (file.language === "python") {
+      const superclasses = node.childForFieldName("superclasses");
+      if (!superclasses) return;
+      const bases = superclasses.text;
+      if (bases.includes("Error") || bases.includes("Exception")) {
+        this.emit(observations, "error-handling.custom-error-class", true, file, node);
+      }
+      return;
+    }
+    const heritage = node.children.find(
+      (c) => c.type === "class_heritage"
+    );
+    if (!heritage) return;
+    if (heritage.text.includes("Error")) {
+      this.emit(observations, "error-handling.custom-error-class", true, file, node);
+    }
+  }
+  detectResultType(node, file, observations) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return;
+    if (RESULT_TYPE_NAMES.has(nameNode.text)) {
+      this.emit(observations, "error-handling.result-type", nameNode.text, file, node);
+    }
+  }
+  detectResultReturnType(node, file, observations) {
+    const returnType = node.childForFieldName("return_type");
+    if (!returnType) return;
+    const text = returnType.text;
+    for (const name of RESULT_TYPE_NAMES) {
+      if (text.includes(name)) {
+        this.emit(observations, "error-handling.result-type", name, file, node);
+        break;
+      }
+    }
+  }
+  detectAssertNever(node, file, observations) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return;
+    const name = nameNode.text;
+    if (name !== "assertNever" && name !== "absurd") return;
+    const params = node.childForFieldName("parameters");
+    const returnType = node.childForFieldName("return_type");
+    const hasNeverParam = params?.text.includes("never") ?? false;
+    const returnsNever = returnType?.text.includes("never") ?? false;
+    if (hasNeverParam || returnsNever) {
+      this.emit(observations, "error-handling.assert-never", true, file, node);
+    }
+  }
+  detectExhaustiveSwitch(node, file, observations) {
+    const body = node.childForFieldName("body");
+    if (!body) return;
+    let defaultCallsAssertNever = false;
+    for (const child of body.children) {
+      if (child.type === "switch_default") {
+        const text = child.text;
+        if (text.includes("assertNever") || text.includes("absurd")) {
+          defaultCallsAssertNever = true;
+        }
+      }
+    }
+    this.emit(
+      observations,
+      "error-handling.exhaustive-switch",
+      defaultCallsAssertNever,
+      file,
+      node
+    );
+  }
+  emit(observations, type, value, file, node) {
+    observations.push({
+      type,
+      category: "error-handling",
+      value,
+      file: file.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+};
+
+// src/extractors/formatting.ts
+import { readFile } from "fs/promises";
+
+// src/extractors/formatting-config.ts
+function parsePrettierConfig(raw, configPath) {
+  const config = JSON.parse(raw);
+  return [
+    ...prettierSyntaxObservations(config, configPath),
+    ...prettierIndentObservations(config, configPath)
+  ];
+}
+function prettierSyntaxObservations(config, configPath) {
+  const observations = [];
+  if (config.semi !== void 0) {
+    observations.push(makeFormattingObs(
+      "formatting.semicolons",
+      config.semi,
+      configPath,
+      1,
+      "config"
+    ));
+  }
+  if (config.singleQuote !== void 0) {
+    observations.push(makeFormattingObs(
+      "formatting.quoteStyle",
+      config.singleQuote ? "single" : "double",
+      configPath,
+      1,
+      "config"
+    ));
+  }
+  if (config.trailingComma !== void 0) {
+    observations.push(makeFormattingObs(
+      "formatting.trailingCommas",
+      config.trailingComma !== "none",
+      configPath,
+      1,
+      "config"
+    ));
+  }
+  return observations;
+}
+function prettierIndentObservations(config, configPath) {
+  const observations = [];
+  if (config.tabWidth !== void 0) {
+    observations.push(makeFormattingObs(
+      "formatting.indentSize",
+      config.tabWidth,
+      configPath,
+      1,
+      "config"
+    ));
+  }
+  if (config.useTabs !== void 0) {
+    observations.push(makeFormattingObs(
+      "formatting.indentStyle",
+      config.useTabs ? "tab" : "space",
+      configPath,
+      1,
+      "config"
+    ));
+  }
+  return observations;
+}
+function parseEditorConfig(raw, configPath) {
+  const observations = [];
+  const section = parseEditorConfigGlobal(raw);
+  if (section.indent_style) {
+    observations.push(makeFormattingObs(
+      "formatting.indentStyle",
+      section.indent_style,
+      configPath,
+      1,
+      "config"
+    ));
+  }
+  if (section.indent_size) {
+    observations.push(makeFormattingObs(
+      "formatting.indentSize",
+      parseInt(section.indent_size, 10),
+      configPath,
+      1,
+      "config"
+    ));
+  }
+  if (section.insert_final_newline) {
+    observations.push(makeFormattingObs(
+      "formatting.trailingNewline",
+      section.insert_final_newline === "true",
+      configPath,
+      1,
+      "config"
+    ));
+  }
+  return observations;
+}
+function parseEditorConfigGlobal(raw) {
+  const result = {};
+  const lines = raw.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed.startsWith("[") || !trimmed) {
+      continue;
+    }
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.substring(0, eqIndex).trim();
+    const value = trimmed.substring(eqIndex + 1).trim();
+    if (key && value) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function makeFormattingObs(type, value, file, line, source) {
+  return {
+    type,
+    category: "formatting",
+    value,
+    file,
+    line,
+    metadata: { source }
+  };
+}
+
+// src/extractors/formatting.ts
+var FormattingExtractor = class {
+  name = "formatting";
+  extract(file) {
+    return this.extractFromSource(file.content, file.filePath);
+  }
+  async extractFromConfig(configPath) {
+    try {
+      const raw = await readFile(configPath, "utf-8");
+      if (configPath.endsWith(".editorconfig")) {
+        return parseEditorConfig(raw, configPath);
+      }
+      if (configPath.includes(".prettierrc") || configPath.includes("prettier.config")) {
+        return parsePrettierConfig(raw, configPath);
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  }
+  extractFromSource(source, filePath) {
+    const observations = [];
+    const lines = source.split("\n");
+    observations.push(...this.detectSemicolons(lines, filePath));
+    observations.push(...this.detectQuoteStyle(source, filePath));
+    observations.push(...this.detectTrailingCommas(source, filePath));
+    observations.push(...this.detectBraceStyle(source, filePath));
+    observations.push(...this.detectIndentation(lines, filePath));
+    return observations;
+  }
+  detectSemicolons(lines, filePath) {
+    let withSemi = 0;
+    let withoutSemi = 0;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || this.isComment(trimmed)) continue;
+      if (this.isStructuralLine(trimmed)) continue;
+      if (trimmed.endsWith(";")) {
+        withSemi++;
+      } else if (this.isStatementStart(trimmed)) {
+        withoutSemi++;
+      }
+    }
+    const total = withSemi + withoutSemi;
+    if (total === 0) return [];
+    return [makeFormattingObs(
+      "formatting.semicolons",
+      withSemi / total > 0.5,
+      filePath,
+      1,
+      "frequency"
+    )];
+  }
+  detectQuoteStyle(source, filePath) {
+    let singleQuotes = 0;
+    let doubleQuotes = 0;
+    const stringPattern = /(?<!=)(?<!\\)(['"])((?:(?!\1|\\).|\\.)*)\1/g;
+    let match;
+    while ((match = stringPattern.exec(source)) !== null) {
+      if (match[1] === "'") {
+        singleQuotes++;
+      } else {
+        doubleQuotes++;
+      }
+    }
+    const total = singleQuotes + doubleQuotes;
+    if (total === 0) return [];
+    return [makeFormattingObs(
+      "formatting.quoteStyle",
+      singleQuotes > doubleQuotes ? "single" : "double",
+      filePath,
+      1,
+      "frequency"
+    )];
+  }
+  detectTrailingCommas(source, filePath) {
+    const trailingCommaPattern = /,\s*[\n\r]\s*[}\]]/g;
+    const noTrailingPattern = /[^,\s]\s*[\n\r]\s*[}\]]/g;
+    const trailing = (source.match(trailingCommaPattern) || []).length;
+    const noTrailing = (source.match(noTrailingPattern) || []).length;
+    const total = trailing + noTrailing;
+    if (total === 0) return [];
+    return [makeFormattingObs(
+      "formatting.trailingCommas",
+      trailing / total > 0.5,
+      filePath,
+      1,
+      "frequency"
+    )];
+  }
+  detectBraceStyle(source, filePath) {
+    const sameLine = (source.match(/\)[^\S\n]*\{/g) || []).length;
+    const nextLine = (source.match(/\)\s*\n\s*\{/g) || []).length;
+    const total = sameLine + nextLine;
+    if (total === 0) return [];
+    return [makeFormattingObs(
+      "formatting.braceStyle",
+      nextLine / total > 0.5 ? "allman" : "1tbs",
+      filePath,
+      1,
+      "frequency"
+    )];
+  }
+  detectIndentation(lines, filePath) {
+    const { tabCount, spaceCount, spaceSizes } = this.countIndentation(lines);
+    const observations = [];
+    const total = tabCount + spaceCount;
+    if (total === 0) return observations;
+    observations.push(makeFormattingObs(
+      "formatting.indentStyle",
+      tabCount > spaceCount ? "tab" : "space",
+      filePath,
+      1,
+      "frequency"
+    ));
+    if (spaceCount > tabCount && spaceSizes.length > 0) {
+      const gcd = this.findGcdOfArray(spaceSizes.filter((s) => s > 0));
+      observations.push(makeFormattingObs(
+        "formatting.indentSize",
+        gcd,
+        filePath,
+        1,
+        "frequency"
+      ));
+    }
+    return observations;
+  }
+  countIndentation(lines) {
+    let tabCount = 0;
+    let spaceCount = 0;
+    const spaceSizes = [];
+    for (const line of lines) {
+      if (!line || line.trim() === "") continue;
+      const leadingWhitespace = line.match(/^(\s+)/);
+      if (!leadingWhitespace) continue;
+      const ws = leadingWhitespace[1];
+      if (ws.includes("	")) {
+        tabCount++;
+      } else if (ws.length > 0) {
+        spaceCount++;
+        spaceSizes.push(ws.length);
+      }
+    }
+    return { tabCount, spaceCount, spaceSizes };
+  }
+  isComment(trimmed) {
+    return trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*");
+  }
+  isStructuralLine(trimmed) {
+    return trimmed.endsWith("{") || trimmed.endsWith("}") || trimmed.endsWith("(") || trimmed.endsWith(",");
+  }
+  isStatementStart(trimmed) {
+    return trimmed.startsWith("const ") || trimmed.startsWith("let ") || trimmed.startsWith("var ") || trimmed.startsWith("return ") || trimmed.startsWith("import ") || trimmed.startsWith("export ");
+  }
+  findGcdOfArray(nums) {
+    if (nums.length === 0) return 2;
+    return nums.reduce((a, b) => this.gcd(a, b));
+  }
+  gcd(a, b) {
+    while (b) {
+      [a, b] = [b, a % b];
+    }
+    return a;
+  }
+};
+
+// src/extractors/complexity.ts
+var TS_FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "method_definition"
+]);
+var PY_FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "function_definition"
+]);
+var TS_NESTING_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_statement",
+  "try_statement"
+]);
+var PY_NESTING_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "while_statement",
+  "try_statement"
+]);
+var TS_BRANCH_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_case",
+  "catch_clause",
+  "ternary_expression"
+]);
+var PY_BRANCH_TYPES = /* @__PURE__ */ new Set([
+  "if_statement",
+  "elif_clause",
+  "for_statement",
+  "while_statement",
+  "except_clause",
+  "conditional_expression"
+]);
+var ComplexityExtractor = class {
+  name = "complexity";
+  extract(file) {
+    const observations = [];
+    const lineCount = file.content.split("\n").filter((l) => l.trim() !== "").length;
+    observations.push({
+      type: "complexity.fileLength",
+      category: "complexity",
+      value: lineCount,
+      file: file.filePath,
+      line: 1
+    });
+    const functionTypes = this.getFunctionTypes(file.language);
+    const functions = this.findFunctions(
+      file.tree.rootNode,
+      functionTypes,
+      file.language
+    );
+    for (const fn of functions) {
+      observations.push(...this.functionObservations(fn, file.filePath));
+    }
+    return observations;
+  }
+  functionObservations(fn, filePath) {
+    const metrics = [
+      ["complexity.functionLength", fn.statementCount],
+      ["complexity.nestingDepth", fn.maxNestingDepth],
+      ["complexity.cyclomatic", fn.cyclomaticComplexity]
+    ];
+    return metrics.map(([type, value]) => ({
+      type,
+      category: "complexity",
+      value,
+      file: filePath,
+      line: fn.line,
+      metadata: { functionName: fn.name }
+    }));
+  }
+  getFunctionTypes(language) {
+    return language === "python" ? PY_FUNCTION_TYPES : TS_FUNCTION_TYPES;
+  }
+  findFunctions(root, functionTypes, language) {
+    const functions = [];
+    const visit = (node) => {
+      if (functionTypes.has(node.type)) {
+        const info = this.analyzeFunctionNode(node, language);
+        if (info) functions.push(info);
+      }
+      for (const child of node.children) {
+        visit(child);
+      }
+    };
+    visit(root);
+    return functions;
+  }
+  analyzeFunctionNode(node, language) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return null;
+    const name = nameNode.text;
+    const body = node.childForFieldName("body");
+    if (!body) return null;
+    const statementCount = this.countStatements(body, language);
+    const maxNestingDepth = this.measureNestingDepth(body, language, 0);
+    const cyclomaticComplexity = this.measureCyclomaticComplexity(
+      body,
+      language
+    );
+    return {
+      name,
+      statementCount,
+      maxNestingDepth,
+      cyclomaticComplexity,
+      line: node.startPosition.row + 1
+    };
+  }
+  countStatements(body, language) {
+    let count = 0;
+    for (const child of body.namedChildren) {
+      if (this.isStatement(child, language)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  isStatement(node, language) {
+    if (language === "python") {
+      return this.isPythonStatement(node);
+    }
+    return this.isTypeScriptStatement(node);
+  }
+  isTypeScriptStatement(node) {
+    const statementTypes = /* @__PURE__ */ new Set([
+      "lexical_declaration",
+      "variable_declaration",
+      "expression_statement",
+      "return_statement",
+      "if_statement",
+      "for_statement",
+      "for_in_statement",
+      "while_statement",
+      "do_statement",
+      "switch_statement",
+      "try_statement",
+      "throw_statement",
+      "break_statement",
+      "continue_statement"
+    ]);
+    return statementTypes.has(node.type);
+  }
+  isPythonStatement(node) {
+    const statementTypes = /* @__PURE__ */ new Set([
+      "expression_statement",
+      "return_statement",
+      "if_statement",
+      "for_statement",
+      "while_statement",
+      "try_statement",
+      "raise_statement",
+      "assert_statement",
+      "pass_statement",
+      "break_statement",
+      "continue_statement",
+      "assignment",
+      "augmented_assignment"
+    ]);
+    return statementTypes.has(node.type);
+  }
+  measureNestingDepth(node, language, depth) {
+    const nestingTypes = language === "python" ? PY_NESTING_TYPES : TS_NESTING_TYPES;
+    let maxDepth = depth;
+    for (const child of node.namedChildren) {
+      if (nestingTypes.has(child.type)) {
+        const childMax = this.measureNestingDepth(
+          child,
+          language,
+          depth + 1
+        );
+        if (childMax > maxDepth) maxDepth = childMax;
+      } else {
+        const childMax = this.measureNestingDepth(
+          child,
+          language,
+          depth
+        );
+        if (childMax > maxDepth) maxDepth = childMax;
+      }
+    }
+    return maxDepth;
+  }
+  measureCyclomaticComplexity(body, language) {
+    let complexity = 1;
+    const branchTypes = language === "python" ? PY_BRANCH_TYPES : TS_BRANCH_TYPES;
+    const visit = (node) => {
+      complexity += this.branchIncrement(node, language, branchTypes);
+      for (const child of node.namedChildren) {
+        visit(child);
+      }
+    };
+    visit(body);
+    return complexity;
+  }
+  branchIncrement(node, language, branchTypes) {
+    let increment = 0;
+    if (branchTypes.has(node.type)) {
+      increment++;
+    }
+    if (node.type === "binary_expression") {
+      const operator = node.childForFieldName("operator");
+      if (operator) {
+        const text = operator.text;
+        if (text === "&&" || text === "||") {
+          increment++;
+        }
+      }
+    }
+    if (language === "python" && node.type === "boolean_operator") {
+      increment++;
+    }
+    return increment;
+  }
+};
+
+// src/extractors/idioms.ts
+var IdiomsExtractor = class {
+  name = "idioms";
+  minLines;
+  minTokens;
+  constructor(options) {
+    this.minLines = options?.minLines ?? 3;
+    this.minTokens = options?.minTokens ?? 25;
+  }
+  extract(_file) {
+    return [];
+  }
+  async extractFromSources(sources) {
+    const observations = [];
+    const clones = await this.detectClones(sources);
+    const groups = this.groupClones(clones);
+    for (const group of groups.values()) {
+      const frequency = group.instances.length;
+      if (frequency < 2) continue;
+      observations.push(this.cloneObservation(group));
+    }
+    return observations;
+  }
+  cloneObservation(group) {
+    const frequency = group.instances.length;
+    const first = group.instances[0];
+    return {
+      type: "idiom.clone",
+      category: "idioms",
+      value: this.summarizeClone(first.fragment),
+      file: first.sourceFile,
+      line: first.startLine,
+      metadata: {
+        frequency,
+        fragment: first.fragment,
+        linesCount: group.linesCount,
+        locations: group.instances.map((inst) => ({
+          file: inst.sourceFile,
+          startLine: inst.startLine,
+          endLine: inst.endLine
+        }))
+      }
+    };
+  }
+  async detectClones(sources) {
+    const { allClones, sourceMap } = await this.runDetector(sources);
+    return allClones.map((clone) => this.toCloneGroup(clone, sourceMap));
+  }
+  async runDetector(sources) {
+    const { Detector, MemoryStore } = await import("@jscpd/core");
+    const { Tokenizer } = await import("@jscpd/tokenizer");
+    const options = {
+      minLines: this.minLines,
+      minTokens: this.minTokens
+    };
+    const store = new MemoryStore();
+    const tokenizer = new Tokenizer();
+    const detector = new Detector(tokenizer, store, [], options);
+    const allClones = [];
+    const sourceMap = /* @__PURE__ */ new Map();
+    for (const source of sources) {
+      sourceMap.set(source.path, source.content);
+      const format = this.languageToFormat(source.language);
+      const detected = await detector.detect(
+        source.path,
+        source.content,
+        format
+      );
+      allClones.push(...detected);
+    }
+    return { allClones, sourceMap };
+  }
+  toCloneGroup(clone, sourceMap) {
+    return {
+      instances: [
+        this.toInstance(clone.duplicationA, sourceMap),
+        this.toInstance(clone.duplicationB, sourceMap)
+      ],
+      linesCount: clone.duplicationA.end.line - clone.duplicationA.start.line + 1
+    };
+  }
+  toInstance(duplication, sourceMap) {
+    const content = sourceMap.get(duplication.sourceId) ?? "";
+    return {
+      sourceFile: duplication.sourceId,
+      startLine: duplication.start.line,
+      endLine: duplication.end.line,
+      fragment: this.extractFragment(
+        content,
+        duplication.start.line,
+        duplication.end.line
+      )
+    };
+  }
+  extractFragment(content, startLine, endLine) {
+    const lines = content.split("\n");
+    return lines.slice(startLine - 1, endLine).join("\n");
+  }
+  languageToFormat(language) {
+    const mapping = {
+      typescript: "typescript",
+      javascript: "javascript",
+      python: "python",
+      tsx: "tsx",
+      jsx: "jsx"
+    };
+    return mapping[language] ?? language;
+  }
+  groupClones(clones) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const clone of clones) {
+      const key = this.normalizeFragment(clone.instances[0]?.fragment ?? "");
+      const existing = groups.get(key);
+      if (existing) {
+        this.mergeInstances(existing, clone);
+      } else {
+        groups.set(key, {
+          instances: [...clone.instances],
+          linesCount: clone.linesCount
+        });
+      }
+    }
+    return groups;
+  }
+  mergeInstances(existing, clone) {
+    for (const inst of clone.instances) {
+      const alreadyTracked = existing.instances.some(
+        (e) => e.sourceFile === inst.sourceFile && e.startLine === inst.startLine
+      );
+      if (!alreadyTracked) {
+        existing.instances.push(inst);
+      }
+    }
+  }
+  normalizeFragment(fragment) {
+    return fragment.replace(/\s+/g, " ").trim().substring(0, 200);
+  }
+  summarizeClone(fragment) {
+    const firstLine = fragment.split("\n")[0]?.trim() ?? "";
+    if (firstLine.length > 80) {
+      return firstLine.substring(0, 77) + "...";
+    }
+    return firstLine;
+  }
+};
+
+// src/extractors/review-voice.ts
+var TOPIC_PATTERNS = [
+  {
+    topic: "naming",
+    patterns: [
+      /\bnam(?:e|ing)\b/i,
+      /\brenam(?:e|ing)\b/i,
+      /\bcamelCase\b/i,
+      /\bsnake_case\b/i,
+      /\bdescriptive\b/i,
+      /\bconfusing\b/i,
+      /\bprefer\s+\S+\s+over\b/i
+    ]
+  },
+  {
+    topic: "error-handling",
+    patterns: [
+      /\berror\s*handl/i,
+      /\bmissing\s+error/i,
+      /\btry\s*\/?\s*catch\b/i,
+      /\bwhat\s+happens\s+if\b/i,
+      /\bedge\s*case/i,
+      /\bnull\b/i,
+      /\bfails?\b/i
+    ]
+  },
+  {
+    topic: "complexity",
+    patterns: [
+      /\bcomplex\b/i,
+      /\btoo\s+long\b/i,
+      /\bsplit\b.*\bup\b/i,
+      /\bextract\b.*\bfunction/i,
+      /\bsmaller\s+functions?\b/i,
+      /\bsimplif/i,
+      /\bnesting\b/i
+    ]
+  },
+  {
+    topic: "style",
+    patterns: [
+      /\bstyle\b/i,
+      /\bformat/i,
+      /\bconsistenc/i,
+      /\bnit\b/i,
+      /\bquotes?\b/i,
+      /\bsemicolon/i,
+      /\bindent/i,
+      /\bwhitespace\b/i
+    ]
+  },
+  {
+    topic: "performance",
+    patterns: [
+      /\bperforman/i,
+      /\bmemoiz/i,
+      /\bre-?render/i,
+      /\boptimiz/i,
+      /\bexpensive\b/i,
+      /\befficien/i,
+      /\bcach/i
+    ]
+  },
+  {
+    topic: "documentation",
+    patterns: [
+      /\bdocument/i,
+      /\bjsdoc\b/i
+    ]
+  },
+  {
+    topic: "testing",
+    patterns: [
+      /\btest/i,
+      /\bcover(?:age)?\b/i,
+      /\bassert/i,
+      /\bmock/i,
+      /\bspec\b/i
+    ]
+  },
+  {
+    topic: "security",
+    patterns: [
+      /\bsecur/i,
+      /\bvulnerab/i,
+      /\bsaniti[zs]/i,
+      /\binject/i,
+      /\bescap/i,
+      /\bxss\b/i
+    ]
+  },
+  {
+    topic: "readability",
+    patterns: [
+      /\breadab/i,
+      /\bearly\s+return/i,
+      /\bguard\s+clause/i
+    ]
+  },
+  {
+    topic: "structure",
+    patterns: [
+      /\bstructur/i,
+      /\barchitect/i,
+      /\borganiz/i,
+      /\bseparati/i
+    ]
+  }
+];
+var KEYWORD_PATTERNS = [
+  { keyword: "early-return", pattern: /\bearly\s+return\b/i },
+  { keyword: "guard-clause", pattern: /\bguard\s+clause\b/i },
+  {
+    keyword: "single-responsibility",
+    pattern: /\bsingle\s+responsib/i
+  },
+  { keyword: "dry", pattern: /\b(?:DRY|don'?t\s+repeat)\b/i },
+  { keyword: "immutability", pattern: /\bimmutab/i },
+  { keyword: "type-safety", pattern: /\btype[\s-]*safe/i },
+  { keyword: "null-check", pattern: /\bnull\s+check/i },
+  { keyword: "magic-number", pattern: /\bmagic\s+number/i }
+];
+var ReviewVoiceExtractor = class {
+  name = "reviewVoice";
+  extract(_file) {
+    return [];
+  }
+  extractFromComments(comments) {
+    if (comments.length === 0) return [];
+    const observations = [];
+    observations.push(...this.categorizeTopics(comments));
+    observations.push(...this.extractKeywords(comments));
+    return observations;
+  }
+  categorizeTopics(comments) {
+    const { topicCounts, topicExamples } = this.countTopics(comments);
+    const observations = [];
+    for (const [topic, count] of topicCounts) {
+      observations.push({
+        type: "reviewVoice.topicFrequency",
+        category: "reviewVoice",
+        value: topic,
+        file: "_reviews",
+        line: 0,
+        metadata: {
+          count,
+          total: comments.length,
+          ratio: count / comments.length,
+          examples: topicExamples.get(topic) ?? []
+        }
+      });
+    }
+    observations.sort(
+      (a, b) => (b.metadata?.count ?? 0) - (a.metadata?.count ?? 0)
+    );
+    return observations;
+  }
+  countTopics(comments) {
+    const topicCounts = /* @__PURE__ */ new Map();
+    const topicExamples = /* @__PURE__ */ new Map();
+    for (const comment of comments) {
+      for (const topic of this.matchTopics(comment.body)) {
+        topicCounts.set(topic, (topicCounts.get(topic) ?? 0) + 1);
+        const examples = topicExamples.get(topic) ?? [];
+        if (examples.length < 3) {
+          examples.push(comment.body);
+          topicExamples.set(topic, examples);
+        }
+      }
+    }
+    return { topicCounts, topicExamples };
+  }
+  matchTopics(body) {
+    const matchedTopics = /* @__PURE__ */ new Set();
+    for (const { topic, patterns } of TOPIC_PATTERNS) {
+      for (const pattern of patterns) {
+        if (pattern.test(body)) {
+          matchedTopics.add(topic);
+          break;
+        }
+      }
+    }
+    return matchedTopics;
+  }
+  extractKeywords(comments) {
+    const keywordCounts = /* @__PURE__ */ new Map();
+    for (const comment of comments) {
+      for (const { keyword, pattern } of KEYWORD_PATTERNS) {
+        if (pattern.test(comment.body)) {
+          keywordCounts.set(keyword, (keywordCounts.get(keyword) ?? 0) + 1);
+        }
+      }
+    }
+    const observations = [];
+    for (const [keyword, count] of keywordCounts) {
+      observations.push({
+        type: "reviewVoice.keyword",
+        category: "reviewVoice",
+        value: keyword,
+        file: "_reviews",
+        line: 0,
+        metadata: {
+          count,
+          total: comments.length
+        }
+      });
+    }
+    return observations;
+  }
+};
+
+// src/extractors/factory.ts
+function createStyleExtractors() {
+  return [
+    new NamingExtractor(),
+    new StructureExtractor(),
+    new ControlFlowExtractor(),
+    new DocumentationExtractor(),
+    new ErrorHandlingExtractor(),
+    new FormattingExtractor(),
+    new ComplexityExtractor(),
+    new IdiomsExtractor(),
+    new ReviewVoiceExtractor()
+  ];
+}
+
+// src/aggregator/confidence.ts
+import { DEFAULT_SEVERITY_THRESHOLDS } from "@titan-design/style-profile";
+var DEFAULT_STABILITY_WEIGHTS = {
+  high: 1,
+  medium: 0.85,
+  low: 0.7
+};
+function computeConfidence(consistency, stability, weights = DEFAULT_STABILITY_WEIGHTS) {
+  return Math.min(1, consistency * weights[stability]);
+}
+function mapSeverity(confidence, thresholds = DEFAULT_SEVERITY_THRESHOLDS) {
+  if (confidence >= thresholds.error) return "error";
+  if (confidence >= thresholds.warn) return "warn";
+  if (confidence >= thresholds.info) return "info";
+  return "off";
+}
+
+// src/aggregator/frequency.ts
+function groupByType(observations) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const obs of observations) {
+    const existing = groups.get(obs.type) ?? [];
+    existing.push(obs);
+    groups.set(obs.type, existing);
+  }
+  return groups;
+}
+function computeDistribution(observations) {
+  const valueCounts = /* @__PURE__ */ new Map();
+  for (const obs of observations) {
+    const key = normalizeValue(obs.value);
+    valueCounts.set(key, (valueCounts.get(key) ?? 0) + 1);
+  }
+  const total = observations.length;
+  let dominant = "";
+  let maxCount = 0;
+  for (const [value, count] of valueCounts) {
+    if (count > maxCount) {
+      maxCount = count;
+      dominant = value;
+    }
+  }
+  return {
+    values: valueCounts,
+    total,
+    dominant,
+    consistency: total > 0 ? maxCount / total : 0
+  };
+}
+function normalizeValue(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function selectExamples(observations, maxExamples) {
+  if (observations.length <= maxExamples) {
+    return [...observations];
+  }
+  const step = Math.floor(observations.length / maxExamples);
+  const examples = [];
+  for (let i = 0; i < observations.length && examples.length < maxExamples; i += step) {
+    examples.push(observations[i]);
+  }
+  return examples;
+}
+
+// src/aggregator/stability.ts
+var STABILITY_MAP = {
+  // Category 1: Naming Conventions
+  "naming.variables": "high",
+  "naming.functions": "high",
+  "naming.types": "high",
+  "naming.constants": "high",
+  "naming.files": "high",
+  "naming.booleans": "medium",
+  "naming.abbreviations": "medium",
+  "naming.parameters": "medium",
+  "naming.enums": "high",
+  "naming.privateMembers": "high",
+  // Category 2: Code Structure
+  "structure.import-group": "high",
+  "structure.import-order": "high",
+  "structure.importPathStyle": "medium",
+  "structure.typeImportSeparation": "medium",
+  "structure.export-style": "high",
+  "structure.barrel-file": "medium",
+  "structure.export-proximity": "medium",
+  "structure.functionLength": "high",
+  "structure.nestingDepth": "high",
+  "structure.fileLength": "medium",
+  "structure.moduleTopology": "low",
+  "structure.fileOrganization": "low",
+  // Category 3: Control Flow Patterns
+  "controlFlow.guardClauses": "high",
+  "controlFlow.earlyReturn": "high",
+  "controlFlow.ternaryPreference": "medium",
+  "controlFlow.arrayMethods": "high",
+  "controlFlow.forStyle": "medium",
+  "controlFlow.asyncAwait": "high",
+  "controlFlow.switchVsIf": "medium",
+  "controlFlow.optionalChaining": "medium",
+  "controlFlow.nullishCoalescing": "low",
+  // Category 4: Error Handling
+  "errorHandling.tryCatchFrequency": "high",
+  "errorHandling.catchSpecificity": "medium",
+  "errorHandling.resultType": "high",
+  "errorHandling.errorReturnTuples": "medium",
+  "errorHandling.customErrorClasses": "medium",
+  "errorHandling.exhaustiveSwitch": "high",
+  "errorHandling.assertNever": "high",
+  "errorHandling.floatingPromises": "medium",
+  "errorHandling.errorBoundary": "low",
+  // Category 5: Documentation
+  "documentation.jsdocPresence": "high",
+  "documentation.publicPrivateCoverage": "medium",
+  "documentation.inlineCommentDensity": "medium",
+  "documentation.commentPlacement": "medium",
+  "documentation.sectionComments": "low",
+  "documentation.moduleHeaders": "medium",
+  "documentation.jsdocTags": "medium",
+  "documentation.voice": "low",
+  "documentation.whyVsWhat": "low",
+  "documentation.redundancy": "low",
+  // Category 6: Type System Usage
+  "typeSystem.annotationDensity": "high",
+  "typeSystem.explicitReturn": "high",
+  "typeSystem.moduleBoundaryTypes": "medium",
+  "typeSystem.inferrableTypes": "medium",
+  "typeSystem.interfaceVsType": "medium",
+  "typeSystem.genericUsage": "low",
+  "typeSystem.readonlyUsage": "medium",
+  "typeSystem.discriminatedUnions": "medium",
+  "typeSystem.utilityTypes": "low",
+  // Category 7: Formatting & Layout
+  "formatting.indentStyle": "high",
+  "formatting.indentSize": "high",
+  "formatting.semicolons": "high",
+  "formatting.quoteStyle": "high",
+  "formatting.trailingCommas": "high",
+  "formatting.braceStyle": "high",
+  "formatting.lineLength": "medium",
+  "formatting.blankLines": "medium",
+  "formatting.destructuring": "medium",
+  "formatting.defaultParams": "low",
+  "formatting.arrowVsFunction": "medium",
+  "formatting.trailingNewline": "high",
+  // Category 8: Higher-Level Patterns
+  "patterns.compositionVsInheritance": "medium",
+  "patterns.classVsFunctional": "high",
+  "patterns.pureFunctions": "low",
+  "patterns.immutability": "medium",
+  "patterns.explicitVsImplicit": "medium",
+  "patterns.dryAdherence": "medium",
+  // Category 9: Habitual Idioms
+  "idiom.clone": "high",
+  "idiom.errorHandlingShape": "medium",
+  "idiom.dataTransformation": "medium",
+  "idiom.apiCallPattern": "medium",
+  "idiom.testStructure": "medium",
+  // Category 10: Review Voice
+  "reviewVoice.topicFrequency": "medium",
+  "reviewVoice.keyword": "medium",
+  "reviewVoice.tone": "low",
+  "reviewVoice.themes": "low",
+  "reviewVoice.values": "low",
+  // Complexity (from task-07)
+  "complexity.functionLength": "high",
+  "complexity.nestingDepth": "high",
+  "complexity.cyclomatic": "high",
+  "complexity.fileLength": "medium"
+};
+function lookupStability(type) {
+  if (STABILITY_MAP[type]) return STABILITY_MAP[type];
+  const category = type.indexOf(".") > 0 ? type.substring(0, type.indexOf(".")) : type;
+  if (STABILITY_MAP[category]) return STABILITY_MAP[category];
+  return "medium";
+}
+
+// src/aggregator/aggregator.ts
+var Aggregator = class {
+  stabilityWeights;
+  severityThresholds;
+  reviewThreshold;
+  maxExamples;
+  constructor(config) {
+    this.stabilityWeights = config?.stabilityWeights ?? DEFAULT_STABILITY_WEIGHTS;
+    this.severityThresholds = config?.severityThresholds ?? DEFAULT_SEVERITY_THRESHOLDS;
+    this.reviewThreshold = config?.reviewThreshold ?? 0.6;
+    this.maxExamples = config?.maxExamples ?? 5;
+  }
+  aggregate(observations) {
+    const grouped = groupByType(observations);
+    const features = /* @__PURE__ */ new Map();
+    const reviewQueue = [];
+    for (const [type, typeObservations] of grouped) {
+      const feature = this.buildFeature(type, typeObservations);
+      features.set(type, feature);
+      if (feature.needsReview) {
+        reviewQueue.push(feature);
+      }
+    }
+    reviewQueue.sort((a, b) => a.confidence - b.confidence);
+    return {
+      features,
+      reviewQueue,
+      summary: {
+        totalObservations: observations.length,
+        totalFeatures: features.size,
+        avgConfidence: averageConfidence(features),
+        featuresNeedingReview: reviewQueue.length
+      }
+    };
+  }
+  buildFeature(type, typeObservations) {
+    const distribution = computeDistribution(typeObservations);
+    const stability = lookupStability(type);
+    const confidence = computeConfidence(
+      distribution.consistency,
+      stability,
+      this.stabilityWeights
+    );
+    return {
+      type,
+      category: this.extractCategory(type),
+      convention: distribution.dominant,
+      distribution,
+      confidence,
+      stability,
+      severity: mapSeverity(confidence, this.severityThresholds),
+      needsReview: confidence < this.reviewThreshold,
+      examples: selectExamples(typeObservations, this.maxExamples)
+    };
+  }
+  extractCategory(type) {
+    const dotIndex = type.indexOf(".");
+    return dotIndex > 0 ? type.substring(0, dotIndex) : type;
+  }
+};
+function averageConfidence(features) {
+  const confidences = Array.from(features.values()).map((f) => f.confidence);
+  return confidences.length > 0 ? confidences.reduce((a, b) => a + b, 0) / confidences.length : 0;
+}
+
+// src/enricher/llm-runner.ts
+var LlmRunner = class {
+  provider;
+  totalTokenBudget;
+  constructor(config) {
+    this.provider = config.provider;
+    this.totalTokenBudget = config.totalTokenBudget ?? 2e4;
+  }
+  async run(jobs) {
+    const results = [];
+    const errors = [];
+    let totalTokensUsed = 0;
+    let budgetExceeded = false;
+    for (const job of jobs) {
+      if (totalTokensUsed >= this.totalTokenBudget) {
+        budgetExceeded = true;
+        break;
+      }
+      totalTokensUsed += await this.runJob(job, results, errors);
+    }
+    return { results, errors, totalTokensUsed, budgetExceeded };
+  }
+  // Returns the tokens the job consumed, which is zero when the provider throws.
+  async runJob(job, results, errors) {
+    try {
+      const response = await this.provider.generate(job.messages, {
+        maxTokens: job.maxTokens
+      });
+      results.push({
+        key: job.key,
+        content: response.content,
+        tokensUsed: response.tokensUsed
+      });
+      return response.tokensUsed;
+    } catch (error) {
+      errors.push({
+        key: job.key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return 0;
+    }
+  }
+};
+
+// src/enricher/prompts.ts
+var DESCRIPTION_PROMPT = {
+  featureTypes: [
+    "documentation.voice",
+    "documentation.whyVsWhat",
+    "documentation.redundancy",
+    "patterns.pureFunctions",
+    "patterns.explicitVsImplicit",
+    "errorHandling.errorBoundary",
+    "structure.fileOrganization"
+  ],
+  system: "You are a code style analyst. Given statistical observations about a developer's coding patterns, write a concise, actionable style rule description. Output ONLY the description text (1-3 sentences). Do not include markdown formatting or headers.",
+  buildUserMessage: (input) => {
+    const lines = [
+      `Feature: ${input.featureType}`,
+      `Dominant pattern: ${JSON.stringify(input.convention)}`,
+      `Confidence: ${(input.confidence * 100).toFixed(0)}%`,
+      `Consistency: ${(input.consistency * 100).toFixed(0)}%`
+    ];
+    if (input.distribution) {
+      lines.push(
+        `Distribution: ${JSON.stringify(input.distribution)}`
+      );
+    }
+    if (input.examples.length > 0) {
+      lines.push("", "Representative code samples:");
+      for (const example of input.examples.slice(0, 5)) {
+        lines.push("```", example, "```");
+      }
+    }
+    lines.push(
+      "",
+      "Write a concise style rule description for this pattern."
+    );
+    return lines.join("\n");
+  },
+  maxTokens: 300
+};
+var REVIEW_VOICE_PROMPT = {
+  featureTypes: [
+    "reviewVoice.tone",
+    "reviewVoice.themes",
+    "reviewVoice.values"
+  ],
+  system: "You are analyzing a developer's code review comments to understand their review voice and priorities. Given topic frequencies and example comments, synthesize a brief description of what this developer cares about in code reviews. Output ONLY the synthesis text (2-4 sentences). Do not include markdown formatting or headers.",
+  buildUserMessage: (input) => {
+    const lines = [
+      `Review topic: ${input.featureType}`,
+      `Pattern: ${JSON.stringify(input.convention)}`
+    ];
+    if (input.distribution) {
+      lines.push(
+        `Topic frequencies: ${JSON.stringify(input.distribution)}`
+      );
+    }
+    if (input.examples.length > 0) {
+      lines.push("", "Example review comments:");
+      for (const example of input.examples.slice(0, 5)) {
+        lines.push(`- "${example}"`);
+      }
+    }
+    lines.push(
+      "",
+      "Synthesize what this developer values in code reviews."
+    );
+    return lines.join("\n");
+  },
+  maxTokens: 400
+};
+var AI_ENRICHED_FEATURES = [
+  ...DESCRIPTION_PROMPT.featureTypes,
+  ...REVIEW_VOICE_PROMPT.featureTypes
+];
+function getPromptForFeature(featureType) {
+  if (DESCRIPTION_PROMPT.featureTypes.includes(featureType)) {
+    return DESCRIPTION_PROMPT;
+  }
+  if (REVIEW_VOICE_PROMPT.featureTypes.includes(featureType)) {
+    return REVIEW_VOICE_PROMPT;
+  }
+  return null;
+}
+function needsAiEnrichment(featureType) {
+  return AI_ENRICHED_FEATURES.includes(featureType);
+}
+
+// src/enricher/enricher.ts
+var Enricher = class {
+  runner;
+  enabled;
+  constructor(config) {
+    this.runner = new LlmRunner({
+      provider: config.provider,
+      totalTokenBudget: config.totalTokenBudget
+    });
+    this.enabled = config.enabled ?? true;
+  }
+  async enrich(features) {
+    if (!this.enabled) {
+      return {
+        enriched: /* @__PURE__ */ new Map(),
+        errors: [],
+        totalTokensUsed: 0,
+        budgetExceeded: false,
+        skipped: true
+      };
+    }
+    const runResult = await this.runner.run(this.buildJobs(features));
+    return toEnrichmentResult(runResult);
+  }
+  buildJobs(features) {
+    const jobs = [];
+    for (const [type, feature] of features) {
+      if (!needsAiEnrichment(type)) continue;
+      const promptTemplate = getPromptForFeature(type);
+      if (!promptTemplate) continue;
+      const input = this.buildPromptInput(type, feature);
+      const messages = [
+        { role: "system", content: promptTemplate.system },
+        {
+          role: "user",
+          content: promptTemplate.buildUserMessage(input)
+        }
+      ];
+      jobs.push({ key: type, messages, maxTokens: promptTemplate.maxTokens });
+    }
+    return jobs;
+  }
+  buildPromptInput(type, feature) {
+    const distributionRecord = {};
+    for (const [key, count] of feature.distribution.values) {
+      distributionRecord[String(key)] = count;
+    }
+    const exampleTexts = feature.examples.map((obs) => {
+      if (typeof obs.value === "string") return obs.value;
+      return JSON.stringify(obs.value);
+    });
+    return {
+      category: feature.category,
+      featureType: type,
+      convention: feature.convention,
+      confidence: feature.confidence,
+      consistency: feature.distribution.consistency,
+      examples: exampleTexts,
+      distribution: distributionRecord
+    };
+  }
+};
+function toEnrichmentResult(runResult) {
+  const enriched = /* @__PURE__ */ new Map();
+  for (const r of runResult.results) {
+    enriched.set(r.key, {
+      featureType: r.key,
+      description: r.content,
+      tokensUsed: r.tokensUsed
+    });
+  }
+  return {
+    enriched,
+    errors: runResult.errors.map((e) => ({
+      featureType: e.key,
+      error: e.error
+    })),
+    totalTokensUsed: runResult.totalTokensUsed,
+    budgetExceeded: runResult.budgetExceeded,
+    skipped: false
+  };
+}
+export {
+  AI_ENRICHED_FEATURES,
+  Aggregator,
+  ComplexityExtractor,
+  ControlFlowExtractor,
+  DocumentationExtractor,
+  Enricher,
+  ErrorHandlingExtractor,
+  FormattingExtractor,
+  IdiomsExtractor,
+  NamingExtractor,
+  ReviewVoiceExtractor,
+  StructureExtractor,
+  computeConfidence,
+  createStyleExtractors,
+  getLanguageFromPath,
+  getSupportedLanguages,
+  lookupStability,
+  mapSeverity,
+  needsAiEnrichment,
+  parseFile,
+  shouldIncludeFile
+};
+//# sourceMappingURL=index.js.map