@titan-design/code-graph 0.6.0 → 0.7.0

package/dist/index.js

@@ -1685,6 +1685,220 @@ import { createHash } from "crypto";
 import * as fs2 from "fs/promises";
 import { getLanguageFromPath as getLanguageFromPath2 } from "@titan-design/code-parser";
 
+// src/analysis/comment-lines.ts
+function commentLineStats(fn, body, lines) {
+  const docstring = pythonDocstring(body);
+  const comments = functionComments(fn, body);
+  const commentLines = rowsOf(comments).size;
+  const bodyLines = codeRows(body, docstring, comments, lines);
+  return {
+    commentLines,
+    docstringLines: docstring ? rowSpan(docstring) : jsDocLines(fn),
+    bodyLines,
+    commentRatio: commentLines / Math.max(bodyLines, 1)
+  };
+}
+function pythonDocstring(body) {
+  if (body.type !== "block") return null;
+  const first = body.namedChildren.find((c) => c !== null && c.type !== "comment");
+  if (first?.type !== "expression_statement" || first.namedChildCount !== 1) return null;
+  return first.namedChildren[0]?.type === "string" ? first : null;
+}
+function bodyStatements(body, docstring = pythonDocstring(body)) {
+  if (body.type !== "block" && body.type !== "statement_block") return [body];
+  return body.namedChildren.filter(
+    (c) => c !== null && c.type !== "comment" && c.id !== docstring?.id
+  );
+}
+function functionComments(fn, body) {
+  if (body.type !== "block") return descendantsOfType(body, "comment");
+  const signatureEnd = fn.childForFieldName("parameters")?.endIndex ?? body.startIndex;
+  return descendantsOfType(fn, "comment").filter((c) => c.startIndex >= signatureEnd);
+}
+function descendantsOfType(root, type) {
+  const out = [];
+  const visit = (node) => {
+    if (node.type === type) out.push(node);
+    for (const child of node.namedChildren) if (child) visit(child);
+  };
+  visit(root);
+  return out;
+}
+function rowSpan(node) {
+  return node.endPosition.row - node.startPosition.row + 1;
+}
+function rowsOf(nodes) {
+  const rows = /* @__PURE__ */ new Set();
+  for (const n of nodes) {
+    for (let r = n.startPosition.row; r <= n.endPosition.row; r++) rows.add(r);
+  }
+  return rows;
+}
+function codeRows(body, docstring, comments, lines) {
+  let count = 0;
+  for (const row of rowsOf(bodyStatements(body, docstring))) {
+    if (codeOnRow(row, lines[row] ?? "", comments).trim() !== "") count++;
+  }
+  return count;
+}
+function codeOnRow(row, text, comments) {
+  let out = text;
+  for (const c of comments) {
+    if (row < c.startPosition.row || row > c.endPosition.row) continue;
+    const from = row === c.startPosition.row ? c.startPosition.column : 0;
+    const to = row === c.endPosition.row ? c.endPosition.column : out.length;
+    out = out.slice(0, from) + " ".repeat(Math.max(to - from, 0)) + out.slice(to);
+  }
+  return out;
+}
+function jsDocLines(fn) {
+  const anchor = declarationAnchor(fn);
+  const prev = anchor.previousNamedSibling;
+  if (prev?.type !== "comment" || !prev.text.startsWith("/**")) return 0;
+  const gap = anchor.startPosition.row - prev.endPosition.row;
+  return gap === 0 || gap === 1 ? rowSpan(prev) : 0;
+}
+function declarationAnchor(fn) {
+  let anchor = fn;
+  if (fn.parent?.type === "variable_declarator") anchor = fn.parent.parent ?? fn;
+  while (anchor.parent?.type === "export_statement") anchor = anchor.parent;
+  return anchor;
+}
+
+// src/analysis/narrating-comments.ts
+var MIN_SHARED = 2;
+var MIN_SHARE_OF_COMMENT = 0.5;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "this",
+  "that",
+  "with",
+  "from",
+  "into",
+  "then",
+  "else",
+  "when",
+  "not",
+  "are",
+  "was",
+  "has",
+  "have",
+  "its",
+  "our",
+  "all",
+  "any",
+  "can",
+  "will",
+  "just",
+  "now",
+  "return",
+  "const",
+  "let",
+  "var",
+  "def",
+  "self",
+  "none",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "new",
+  "await",
+  "async",
+  "function"
+]);
+var IDENTIFIER_TYPES = /* @__PURE__ */ new Set([
+  "identifier",
+  "property_identifier",
+  "shorthand_property_identifier",
+  "type_identifier"
+]);
+function countNarratingComments(fn, body) {
+  let count = 0;
+  for (const comment of functionComments(fn, body)) {
+    const target = trailedStatement(comment) ?? nextStatement(comment);
+    if (target && narrates(comment.text, target)) count++;
+  }
+  return count;
+}
+function trailedStatement(comment) {
+  const prev = comment.previousNamedSibling;
+  if (!prev || prev.type === "comment") return null;
+  return prev.endPosition.row === comment.startPosition.row ? prev : null;
+}
+function identifierTokens(text) {
+  const words = text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/);
+  const out = /* @__PURE__ */ new Set();
+  for (const w of words) {
+    const t = w.toLowerCase();
+    if (t.length >= 3 && !STOPWORDS.has(t)) out.add(t);
+  }
+  return out;
+}
+function nextStatement(comment) {
+  let next = comment.nextNamedSibling;
+  while (next?.type === "comment") next = next.nextNamedSibling;
+  if (next?.type !== "block") return next;
+  return next.namedChildren.find((c) => c !== null && c.type !== "comment") ?? null;
+}
+function narrates(commentText, statement) {
+  const said = identifierTokens(commentText);
+  if (said.size === 0) return false;
+  const code = identifierTokens(statementIdentifiers(statement).join(" "));
+  let shared = 0;
+  for (const t of said) if (code.has(t)) shared++;
+  return shared >= MIN_SHARED || shared / said.size >= MIN_SHARE_OF_COMMENT;
+}
+function statementIdentifiers(statement) {
+  const out = [];
+  const visit = (node) => {
+    if (IDENTIFIER_TYPES.has(node.type)) out.push(node.text);
+    for (const child of node.namedChildren) if (child) visit(child);
+  };
+  visit(statement);
+  return out;
+}
+
+// src/analysis/exception-handling.ts
+var EXCEPTION_METRIC_NAMES = ["except_count", "except_density", "swallowed_except"];
+var HANDLER_TYPES = ["except_clause", "except_group_clause", "catch_clause"];
+var SILENT_STATEMENTS = /* @__PURE__ */ new Set(["pass_statement", "continue_statement", "empty_statement"]);
+var EMPTY_VALUES = /* @__PURE__ */ new Set(["None", "null", "undefined"]);
+var LOGGING_TOKENS = /* @__PURE__ */ new Set(["log", "logger", "logging", "warn", "warning", "warnings", "print", "console"]);
+function exceptionMetrics(nodeId, root, loc) {
+  const handlers = HANDLER_TYPES.flatMap((type) => descendantsOfType(root, type));
+  const swallowed = handlers.filter((h) => isSwallowed(h)).length;
+  return [
+    { nodeId, name: "except_count", value: handlers.length, unit: "count" },
+    { nodeId, name: "except_density", value: loc === 0 ? 0 : handlers.length * 100 / loc, unit: "per100loc" },
+    { nodeId, name: "swallowed_except", value: swallowed, unit: "count" }
+  ];
+}
+function isSwallowed(handler) {
+  const body = handler.childForFieldName("body") ?? handler.namedChildren.find((c) => c?.type === "block");
+  if (!body) return false;
+  const statements = bodyStatements(body, null);
+  if (statements.length === 0) return true;
+  return statements.length === 1 && isSilent(statements[0]);
+}
+function isSilent(statement) {
+  if (SILENT_STATEMENTS.has(statement.type)) return true;
+  const value = statement.namedChildren[0];
+  if (statement.type === "return_statement") return !value || EMPTY_VALUES.has(value.text);
+  if (statement.type !== "expression_statement" || !value) return false;
+  if (value.type === "ellipsis") return true;
+  return isLoggingCall(value);
+}
+function isLoggingCall(node) {
+  if (node.type !== "call" && node.type !== "call_expression") return false;
+  const callee = node.childForFieldName("function");
+  if (!callee) return false;
+  for (const token of identifierTokens(callee.text)) if (LOGGING_TOKENS.has(token)) return true;
+  return false;
+}
+
 // src/cognitive-complexity.ts
 function cognitiveComplexityOf(body, language) {
   const handler = language === "python" ? PY_HANDLER : TS_HANDLER;
@@ -1937,12 +2151,97 @@ function areLinked(a, b) {
   return false;
 }
 
+// src/analysis/pass-through.ts
+var RECEIVERS = /* @__PURE__ */ new Set(["self", "cls"]);
+var CALL_TYPES = /* @__PURE__ */ new Set(["call", "call_expression"]);
+var WRAPPER_TYPES = /* @__PURE__ */ new Set(["return_statement", "expression_statement"]);
+var PY_NAMED_PARAMS = /* @__PURE__ */ new Set(["default_parameter", "typed_default_parameter"]);
+var PY_SEPARATORS = /* @__PURE__ */ new Set(["keyword_separator", "positional_separator"]);
+function isPassThrough(fn, body) {
+  const call = soleCall(body);
+  if (!call) return false;
+  const params = parameterShapes(fn);
+  if (!params || params.length === 0) return false;
+  const args = argumentShapes(call);
+  return args !== null && args.length === params.length && args.every((a, i) => a === params[i]);
+}
+function soleCall(body) {
+  const statements = bodyStatements(body);
+  if (statements.length !== 1) return null;
+  const only = statements[0];
+  if (CALL_TYPES.has(only.type)) return only;
+  if (!WRAPPER_TYPES.has(only.type) || only.namedChildCount !== 1) return null;
+  const value = only.namedChildren[0];
+  return CALL_TYPES.has(value.type) ? value : null;
+}
+function parameterShapes(fn) {
+  const bare = fn.childForFieldName("parameter");
+  if (bare) return [bare.text];
+  const list = fn.childForFieldName("parameters");
+  if (!list) return null;
+  const shapes = [];
+  for (const p of list.namedChildren) {
+    if (!p || p.type === "comment" || PY_SEPARATORS.has(p.type)) continue;
+    const shape = parameterShape(p);
+    if (shape === null) return null;
+    shapes.push(shape);
+  }
+  return RECEIVERS.has(shapes[0] ?? "") ? shapes.slice(1) : shapes;
+}
+function parameterShape(p) {
+  if (p.type === "identifier") return p.text;
+  if (p.type === "list_splat_pattern" || p.type === "dictionary_splat_pattern") return p.text;
+  if (PY_NAMED_PARAMS.has(p.type)) return p.childForFieldName("name")?.text ?? null;
+  if (p.type === "typed_parameter") return parameterShape(p.namedChildren[0]);
+  if (p.type === "required_parameter" || p.type === "optional_parameter") {
+    const pattern = p.childForFieldName("pattern");
+    return pattern ? tsPatternShape(pattern) : null;
+  }
+  return tsPatternShape(p);
+}
+function tsPatternShape(pattern) {
+  if (pattern.type === "identifier") return pattern.text;
+  if (pattern.type === "rest_pattern") return `...${pattern.namedChildren[0]?.text ?? ""}`;
+  if (pattern.type === "assignment_pattern") {
+    const left = pattern.childForFieldName("left");
+    return left ? tsPatternShape(left) : null;
+  }
+  return null;
+}
+function argumentShapes(call) {
+  const list = call.childForFieldName("arguments");
+  if (!list || list.type !== "argument_list" && list.type !== "arguments") return null;
+  const shapes = [];
+  for (const a of list.namedChildren) {
+    if (!a || a.type === "comment") continue;
+    const shape = argumentShape(a);
+    if (shape === null) return null;
+    shapes.push(shape);
+  }
+  return shapes;
+}
+function argumentShape(a) {
+  if (a.type === "identifier") return a.text;
+  const inner = a.namedChildren[0];
+  if (inner?.type !== "identifier") return null;
+  if (a.type === "list_splat") return `*${inner.text}`;
+  if (a.type === "dictionary_splat") return `**${inner.text}`;
+  if (a.type === "spread_element") return `...${inner.text}`;
+  return null;
+}
+
 // src/symbol-metrics.ts
 var SYMBOL_METRICS = [
   { name: "symbol_cognitive", stat: "cognitive", unit: "count" },
   { name: "symbol_cyclomatic", stat: "cyclomatic", unit: "count" },
   { name: "symbol_loc", stat: "loc", unit: "lines" },
-  { name: "symbol_max_nesting", stat: "nestingDepth", unit: "count" }
+  { name: "symbol_max_nesting", stat: "nestingDepth", unit: "count" },
+  { name: "symbol_comment_lines", stat: "commentLines", unit: "lines" },
+  { name: "symbol_docstring_lines", stat: "docstringLines", unit: "lines" },
+  { name: "symbol_body_lines", stat: "bodyLines", unit: "lines" },
+  { name: "symbol_comment_ratio", stat: "commentRatio", unit: "ratio" },
+  { name: "symbol_narrating_comments", stat: "narratingComments", unit: "count" },
+  { name: "symbol_pass_through", stat: "passThrough", unit: "count" }
 ];
 var SYMBOL_METRIC_NAMES = SYMBOL_METRICS.map((m) => m.name);
 function symbolMetrics(fileId2, stats, symbolNames) {
@@ -1966,6 +2265,13 @@ function symbolMetrics(fileId2, stats, symbolNames) {
   }
   return out;
 }
+function functionShapeStats(fn, body, lines) {
+  return {
+    ...commentLineStats(fn, body, lines),
+    narratingComments: countNarratingComments(fn, body),
+    passThrough: isPassThrough(fn, body) ? 1 : 0
+  };
+}
 
 // src/source-metrics.ts
 var TS_FUNCTION_TYPES = /* @__PURE__ */ new Set([
@@ -2016,7 +2322,8 @@ var SOURCE_METRIC_NAMES = /* @__PURE__ */ new Set([
   "max_nesting_depth",
   "class_count",
   "lcom4_max",
-  // Per-symbol complexity, loc and nesting (C-58, C-64, TP-317), keyed
+  ...EXCEPTION_METRIC_NAMES,
+  // Per-symbol complexity, size, comments and shape (C-58, C-64, TP-317, TP-322), keyed
   // to `symbol` node ids. Source-local like the file-level metrics above, so an
   // unchanged file carries them forward — but their nodeId is `<fileId>#<name>`,
   // so the reuse basis buckets them under the symbol's parent file (incremental.ts).
@@ -2076,6 +2383,7 @@ function metricsForFile(nodeId, file, symbolNames) {
   }
   out.push(...symbolMetrics(nodeId, stats, symbolNames));
   out.push(...computeLcomMetrics(file, nodeId));
+  out.push(...exceptionMetrics(nodeId, file.tree.rootNode, loc));
   return out;
 }
 function countLoc(content) {
@@ -2084,6 +2392,7 @@ function countLoc(content) {
 function analyzeFunctions(file) {
   const stats = [];
   const fnTypes = file.language === "python" ? PY_FUNCTION_TYPES : TS_FUNCTION_TYPES;
+  const lines = file.content.split("\n");
   walkScopes(file.tree.rootNode, file.language === "python", (node, scope) => {
     const fn = functionAt(node, fnTypes);
     if (!fn) return;
@@ -2092,7 +2401,8 @@ function analyzeFunctions(file) {
       cyclomatic: cyclomaticOf(fn.body, file.language),
       cognitive: cognitiveComplexityOf(fn.body, file.language),
       nestingDepth: nestingDepthOf(fn.body, file.language, 0),
-      loc: fn.node.endPosition.row - fn.node.startPosition.row + 1
+      loc: fn.node.endPosition.row - fn.node.startPosition.row + 1,
+      ...functionShapeStats(fn.node, fn.body, lines)
     });
   });
   return stats;
@@ -2149,7 +2459,7 @@ var TERMINALS = /* @__PURE__ */ new Set([
 ]);
 var SCOPE_TYPES = /* @__PURE__ */ new Set(["function_definition", "lambda", "class_definition"]);
 var SPLAT_TYPES = /* @__PURE__ */ new Set(["list_splat_pattern", "dictionary_splat_pattern"]);
-var RECEIVERS = /* @__PURE__ */ new Set(["self", "cls"]);
+var RECEIVERS2 = /* @__PURE__ */ new Set(["self", "cls"]);
 function pythonDeadCode(root) {
   const out = { unreachable: 0, locals: 0, params: 0 };
   const visit = (node) => {
@@ -2211,7 +2521,7 @@ function ownParamNames(fn) {
   for (const p of params.namedChildren) {
     if (!p || p.type === "keyword_separator" || p.type === "positional_separator") continue;
     const id = paramIdentifier(p);
-    out.push(id && !RECEIVERS.has(id.text) ? id.text : null);
+    out.push(id && !RECEIVERS2.has(id.text) ? id.text : null);
   }
   return out;
 }
@@ -3118,7 +3428,7 @@ function qualifiedByName(file) {
 }
 
 // src/indexer.ts
-var INDEX_VERSION = "0.16.0";
+var INDEX_VERSION = "0.17.0";
 var LANGUAGES = ["typescript", "python"];
 function canonicalizePath(p) {
   try {
@@ -4106,6 +4416,96 @@ var SOURCE = [
     source: "source-metrics",
     description: "Deepest block nesting inside the function a symbol names; the max when several share the name."
   },
+  {
+    name: "symbol_comment_lines",
+    unit: "lines",
+    appliesTo: SYMBOL,
+    rollup: "max",
+    direction: "neutral",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Rows holding a comment inside the function a symbol names, the docstring excluded; the max when several share the name."
+  },
+  {
+    name: "symbol_docstring_lines",
+    unit: "lines",
+    appliesTo: SYMBOL,
+    rollup: "max",
+    direction: "neutral",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Rows of the function's docstring: the Python docstring, or the JSDoc block attached to a TypeScript declaration."
+  },
+  {
+    name: "symbol_body_lines",
+    unit: "lines",
+    appliesTo: SYMBOL,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Non-blank rows of the function's body that hold code, comments and the docstring excluded."
+  },
+  {
+    name: "symbol_comment_ratio",
+    unit: "ratio",
+    appliesTo: SYMBOL,
+    rollup: "max",
+    direction: "neutral",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "symbol_comment_lines / max(symbol_body_lines, 1). High values suggest narration; zero is not a defect."
+  },
+  {
+    name: "symbol_narrating_comments",
+    unit: "count",
+    appliesTo: SYMBOL,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Comments in the body whose words overlap the next statement's identifiers by 2 tokens or half the comment. A candidate signal."
+  },
+  {
+    name: "symbol_pass_through",
+    unit: "count",
+    appliesTo: SYMBOL,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "1 when the function's body is one call forwarding every parameter, in order, as a bare argument; else 0."
+  },
+  {
+    name: "except_count",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "neutral",
+    absent: "zero",
+    source: "exception-handling",
+    description: "Python except clauses and TypeScript catch clauses in the file."
+  },
+  {
+    name: "except_density",
+    unit: "per100loc",
+    appliesTo: FILE,
+    rollup: "none",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "exception-handling",
+    description: "except_count per 100 non-blank lines. Recompute from the sums for a group."
+  },
+  {
+    name: "swallowed_except",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "exception-handling",
+    description: "Handlers whose body is empty, pass, ..., continue, a bare or empty return, or a single logging call."
+  },
   {
     name: "class_count",
     unit: "count",
@@ -4529,6 +4929,43 @@ function locateNode(node) {
   return location;
 }
 
+// src/check/outlier-rule.ts
+var DEFAULT_OUTLIER_MIN_SAMPLE = 20;
+function runMetricOutlierRule(rule, ctx) {
+  const pool = rule.kind === "symbol" ? ctx.symbolNodes : ctx.nodes;
+  const carriers = [];
+  for (const node of pool) {
+    if (node.kind !== rule.kind) continue;
+    const value = ctx.metricsByNode.get(node.id)?.get(rule.metric);
+    if (value !== void 0) carriers.push({ node, value });
+  }
+  if (carriers.length < (rule.minSample ?? DEFAULT_OUTLIER_MIN_SAMPLE)) return [];
+  const threshold = percentileOf(carriers.map((c) => c.value), rule.percentile);
+  return carriers.filter((c) => c.value > threshold).map((c) => toViolation(rule, c.node, c.value, threshold));
+}
+function percentileOf(values, percentile) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const rank = percentile / 100 * (sorted.length - 1);
+  const lower = Math.floor(rank);
+  const upper = Math.min(lower + 1, sorted.length - 1);
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (rank - lower);
+}
+function toViolation(rule, node, value, threshold) {
+  const bound = `p${formatNumber(rule.percentile)} ${formatNumber(threshold)}`;
+  return {
+    ruleId: rule.id,
+    severity: severityOf(rule),
+    nodeId: node.id,
+    metric: rule.metric,
+    value,
+    threshold,
+    message: `${rule.metric}=${formatNumber(value)} > ${bound}`,
+    ...locateNode(node),
+    evidence: `${rule.metric}=${formatNumber(value)} (${bound})`,
+    tool: CODE_GRAPH_TOOL
+  };
+}
+
 // src/check/metric-rules.ts
 function nodeFilter(rule) {
   return {
@@ -4548,7 +4985,7 @@ function candidateNodes(rule, ctx) {
   const pool = rule.kind === "symbol" ? ctx.symbolNodes : ctx.nodes;
   return pool.filter((node) => passesFilter(node, filter));
 }
-function toViolation(rule, breach) {
+function toViolation2(rule, breach) {
   return {
     ruleId: rule.id,
     severity: severityOf(rule),
@@ -4578,7 +5015,7 @@ function runMetricMaxRule(rule, ctx) {
   for (const node of candidateNodes(rule, ctx)) {
     const value = ctx.metricsByNode.get(node.id)?.get(rule.metric);
     if (value === void 0 || value <= rule.max) continue;
-    out.push(toViolation(rule, thresholdBreach(node, rule.metric, value, "max", rule.max)));
+    out.push(toViolation2(rule, thresholdBreach(node, rule.metric, value, "max", rule.max)));
   }
   return out;
 }
@@ -4587,7 +5024,7 @@ function runMetricMinRule(rule, ctx) {
   for (const node of candidateNodes(rule, ctx)) {
     const value = ctx.metricsByNode.get(node.id)?.get(rule.metric);
     if (value === void 0 || value >= rule.min) continue;
-    out.push(toViolation(rule, thresholdBreach(node, rule.metric, value, "min", rule.min)));
+    out.push(toViolation2(rule, thresholdBreach(node, rule.metric, value, "min", rule.min)));
   }
   return out;
 }
@@ -4600,7 +5037,7 @@ function runMetricProductMaxRule(rule, ctx) {
     if (!components) continue;
     const product = components.reduce((a, b) => a * b, 1);
     if (product <= rule.max) continue;
-    out.push(toViolation(rule, productBreach(rule, node, components, product)));
+    out.push(toViolation2(rule, productBreach(rule, node, components, product)));
   }
   return out;
 }
@@ -4634,6 +5071,8 @@ function runRule(rule, ctx) {
       return runMetricMinRule(rule, ctx);
     case "metric-product-max":
       return runMetricProductMaxRule(rule, ctx);
+    case "metric-outlier":
+      return runMetricOutlierRule(rule, ctx);
     case "forbid-import":
       return runForbidImportRule(rule, ctx);
     case "layered-deps":
@@ -4778,6 +5217,8 @@ function validateRule(raw, index, warn) {
       return assertMetricMin(r, warn);
     case "metric-product-max":
       return assertMetricProductMax(r, warn);
+    case "metric-outlier":
+      return assertMetricOutlier(r, warn);
     case "forbid-import":
       return assertForbidImport(r);
     case "layered-deps":
@@ -4887,6 +5328,29 @@ function assertMetricMin(r, warn) {
     excludeRoles: parseRoleArray(ruleId, r.excludeRoles, warn)
   };
 }
+var NODE_KINDS = /* @__PURE__ */ new Set(["package", "module", "file", "symbol", "external"]);
+function assertMetricOutlier(r, warn) {
+  if (typeof r.metric !== "string") throw new Error(`${r.id}: metric must be a string`);
+  if (typeof r.kind !== "string" || !NODE_KINDS.has(r.kind)) {
+    throw new Error(`${r.id}: kind must be one of ${[...NODE_KINDS].join(", ")}`);
+  }
+  if (typeof r.percentile !== "number" || r.percentile < 50 || r.percentile > 100) {
+    throw new Error(`${r.id}: percentile must be a number from 50 to 100`);
+  }
+  if (r.minSample !== void 0 && (!Number.isInteger(r.minSample) || r.minSample < 1)) {
+    throw new Error(`${r.id}: minSample must be a positive integer`);
+  }
+  const ruleId = r.id;
+  return {
+    type: "metric-outlier",
+    id: ruleId,
+    metric: healMetricName(r.metric, ruleId, warn),
+    kind: r.kind,
+    percentile: r.percentile,
+    minSample: r.minSample,
+    severity: r.severity
+  };
+}
 function assertForbidImport(r) {
   if (typeof r.from !== "string") throw new Error(`${r.id}: from must be a string`);
   if (typeof r.to !== "string") throw new Error(`${r.id}: to must be a string`);
@@ -5587,7 +6051,9 @@ export {
   CodeGraphStore,
   DEAD_CODE_METRIC_NAMES,
   DEFAULT_CHURN_WINDOWS,
+  DEFAULT_OUTLIER_MIN_SAMPLE,
   DOMAIN_DDL,
+  EXCEPTION_METRIC_NAMES,
   GROWTH_RISK_METRIC_NAMES,
   INDEX_VERSION,
   KIT,
@@ -5600,6 +6066,7 @@ export {
   SOURCE_METRIC_NAMES,
   SYMBOL_EMBEDDING_NAMESPACE,
   SYMBOL_ID_SEP,
+  SYMBOL_METRIC_NAMES,
   TsMorphGraphExtractor,
   aggregateMetrics,
   aliasChain,
@@ -5682,6 +6149,7 @@ export {
   parseFile2 as parseFile,
   parseSymbolId,
   patternToRegex,
+  percentileOf,
   planPrune,
   priorSnapshotForRef,
   pruneDanglingReferences,