weavatrix 0.2.13 → 0.2.15

package/src/analysis/duplicates.tokenize.js

@@ -149,11 +149,17 @@ export function extractLargeStrings(text, { py = false, cs = false, minLines = 6
 
 // one raw token stream; the two modes differ only in identifier canonicalization
 export function tokenize(text) {
-  const raw = text.match(/[A-Za-z_$][\w$]*|\d+(?:\.\d+)?|[^\s\w]/g) || [];
+  const raw = text.match(/[A-Za-z_$][\w$]*|(?:0[xX][\dA-Fa-f_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)n?|[^\s\w]/g) || [];
   const strict = [];
   const renamed = [];
   for (const t of raw) {
-    if (/^\d/.test(t)) { strict.push("N"); renamed.push("N"); continue; }
+    if (/^\d/.test(t)) {
+      // Numeric constants are behavior, not renameable identifiers. Preserve
+      // their value so same-shape limit/config tables with different numbers do
+      // not become perfect clones; a small constant edit still leaves the rest
+      // of a genuine copied body highly similar.
+      strict.push(`N:${t}`); renamed.push(`N:${t}`); continue;
+    }
     if (/^[A-Za-z_$]/.test(t) && !KEYWORDS.has(t)) { strict.push(t); renamed.push("I"); continue; }
     strict.push(t); renamed.push(t);
   }
@@ -178,5 +184,9 @@ export function fingerprints(toks) {
     for (let j = i; j < Math.min(i + W, hashes.length); j++) if (hashes[j] < min) min = hashes[j];
     fp.add(min);
   }
+  // Winnowing can skip every changed literal in a repetitive policy table.
+  // Exact numeric anchors keep behavior-defining limits in the similarity
+  // denominator while leaving ordinary copied bodies tolerant of a small edit.
+  for (const token of toks) if (token.startsWith("N:")) fp.add(`numeric:${token}`);
   return fp;
 }

package/src/analysis/endpoints/common.js

@@ -0,0 +1,62 @@
+export const MAX_ENDPOINT_FILES = 3_000;
+export const MAX_ENDPOINTS = 2_000;
+export const HTTP_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "TRACE", "CONNECT", "ALL", "ANY"]);
+
+export function lineAt(text, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < text.length; i++) if (text[i] === "\n") line++;
+  return line;
+}
+
+// Preserve offsets and literals while hiding comments from regex extractors.
+export function maskComments(text, { hashComments = false } = {}) {
+  const chars = String(text || "").split("");
+  let quote = "", escaped = false, lineComment = false, blockComment = false;
+  for (let i = 0; i < chars.length; i++) {
+    const ch = chars[i], next = chars[i + 1];
+    if (lineComment) {
+      if (ch === "\n" || ch === "\r") lineComment = false;
+      else chars[i] = " ";
+      continue;
+    }
+    if (blockComment) {
+      if (ch === "*" && next === "/") { chars[i] = chars[i + 1] = " "; i++; blockComment = false; }
+      else if (ch !== "\n" && ch !== "\r") chars[i] = " ";
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") { quote = ch; continue; }
+    if (ch === "/" && next === "/") { chars[i] = chars[i + 1] = " "; i++; lineComment = true; continue; }
+    if (ch === "/" && next === "*") { chars[i] = chars[i + 1] = " "; i++; blockComment = true; continue; }
+    if (hashComments && ch === "#") { chars[i] = " "; lineComment = true; }
+  }
+  return chars.join("");
+}
+
+export function handlerName(expr) {
+  const source = String(expr || "").trim();
+  if (!source || /=>/.test(source) || /^\s*(async\s+)?function\b/.test(source) || /^\s*(?:async\s+)?(?:move\s+)?\|[^|]*\|/.test(source)) return "";
+  const turbofish = /(?:^|::)([A-Za-z_][\w]*)\s*::<[\s\S]*>\s*$/.exec(source);
+  if (turbofish) return turbofish[1];
+  const identifiers = source.match(/[A-Za-z_$][\w$]*/g);
+  if (!identifiers) return "";
+  const skipped = new Set(["async", "function", "await", "req", "res", "ctx", "request", "response", "next", "return"]);
+  for (let i = identifiers.length - 1; i >= 0; i--) if (!skipped.has(identifiers[i])) return identifiers[i];
+  return "";
+}
+
+export function handlerReference(expr) {
+  const source = String(expr || "").trim();
+  if (!source || /=>/.test(source) || /^\s*(async\s+)?function\b/.test(source)) return "";
+  const refs = [...source.matchAll(/([A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)+)/g)];
+  return refs.length ? refs.at(-1)[1].replace(/\s+/g, "") : "";
+}
+
+export const looksLikePath = (path) => typeof path === "string" && /^\/[\w\-./:{}*$?]*$/.test(path) && !path.includes("://");
+export const cleanPath = (path) => String(path || "").replace(/\/+$/, "") || "/";
+export const normalizedFile = (file) => String(file || "").replace(/\\/g, "/").replace(/^\.\//, "");

package/src/analysis/endpoints/extract.js

@@ -0,0 +1,107 @@
+import { extractRustEndpoints } from "../endpoints-rust.js";
+import { extractSpringEndpoints } from "../endpoints-java.js";
+import { HTTP_METHODS, cleanPath, handlerName, handlerReference, lineAt, looksLikePath, maskComments } from "./common.js";
+
+const HTTP_CLIENT_CALLER = /^(axios|https?|fetch|ky|got|superagent|needle|undici|xhr|\$http|http[Cc]lient|api[Cc]lient|rest[Cc]lient)$/;
+const OPENAPI_BLOCK = /\boperationId\b|\bresponses\s*:|\brequestBody\b|\bschemaRef\b|\boperation\s*\(|\bsummary\s*:/;
+
+export function nextRoutePath(file) {
+  const parts = String(file || "").replace(/\\/g, "/").split("/").filter(Boolean);
+  if (!/^route\.[cm]?[jt]s$/i.test(parts.at(-1) || "")) return "";
+  const appAt = parts.lastIndexOf("app");
+  if (appAt < 0) return "";
+  const route = [];
+  for (let segment of parts.slice(appAt + 1, -1)) {
+    if (!segment || /^\([^)]*\)$/.test(segment) || segment.startsWith("@")) continue;
+    segment = segment.replace(/^\((?:\.{1,3})\)/, "");
+    let match;
+    if ((match = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(segment))) segment = `*${match[1]}?`;
+    else if ((match = /^\[\.\.\.([^\]]+)\]$/.exec(segment))) segment = `*${match[1]}`;
+    else if ((match = /^\[([^\]]+)\]$/.exec(segment))) segment = `:${match[1]}`;
+    if (segment) route.push(segment);
+  }
+  return `/${route.join("/")}`;
+}
+
+export function extractEndpointsFromText(text, file) {
+  const out = [];
+  const py = /\.py$/i.test(file), rust = /\.rs$/i.test(file), java = /\.java$/i.test(file);
+  const scanText = maskComments(text, { hashComments: py });
+  const add = (method, path, expr, index) => {
+    const normalizedPath = cleanPath(path);
+    const normalizedMethod = String(method || "ANY").toUpperCase();
+    if (!looksLikePath(normalizedPath) || !HTTP_METHODS.has(normalizedMethod)) return;
+    const handler = handlerName(expr);
+    const handlerRef = handlerReference(expr);
+    out.push({ method: normalizedMethod, path: normalizedPath, handler, ...(handlerRef ? { handlerRef } : {}), file, line: lineAt(text, index) });
+  };
+
+  const nextPath = nextRoutePath(file);
+  if (nextPath) {
+    const seen = new Set();
+    const direct = /\bexport\s+(?:(?:async|declare)\s+)*(?:function\s+|(?:const|let|var)\s+)(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\b/g;
+    let match;
+    while ((match = direct.exec(scanText))) {
+      const method = match[1].toUpperCase();
+      if (!seen.has(method)) { seen.add(method); add(method, nextPath, method, match.index); }
+    }
+    const lists = /\bexport\s*\{([^}]+)\}/g;
+    while ((match = lists.exec(scanText))) {
+      for (const item of match[1].split(",")) {
+        const methodMatch = /^\s*([A-Za-z_$][\w$]*)(?:\s+as\s+(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS))?\s*$/.exec(item);
+        if (!methodMatch || (!methodMatch[2] && !HTTP_METHODS.has(methodMatch[1]))) continue;
+        const method = String(methodMatch[2] || methodMatch[1]).toUpperCase();
+        if (HTTP_METHODS.has(method) && !seen.has(method)) { seen.add(method); add(method, nextPath, methodMatch[1], match.index); }
+      }
+    }
+  }
+
+  if (rust) extractRustEndpoints(scanText, add);
+  if (java) {
+    out.push(...extractSpringEndpoints(scanText, file));
+    return out;
+  }
+
+  const objKey = /(["'`])(\/[^"'`]*)\1\s*:\s*(\{)?/g;
+  let match;
+  while ((match = objKey.exec(scanText))) {
+    const path = match[2], keyIndex = match.index;
+    if (match[3]) {
+      let cursor = objKey.lastIndex, depth = 1;
+      const start = cursor;
+      while (cursor < scanText.length && depth > 0) {
+        if (scanText[cursor] === "{") depth++;
+        else if (scanText[cursor] === "}") depth--;
+        cursor++;
+      }
+      const body = scanText.slice(start, cursor - 1);
+      objKey.lastIndex = cursor;
+      if (OPENAPI_BLOCK.test(body)) continue;
+      const methodEntry = /\b(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\b\s*:\s*([^,\n}]+)/gi;
+      let entry;
+      while ((entry = methodEntry.exec(body))) add(entry[1], path, entry[2], keyIndex);
+    } else {
+      const expression = /^([^,\n}]+)/.exec(scanText.slice(objKey.lastIndex, objKey.lastIndex + 200));
+      if (expression && !/^\s*(?:\{|["'`\[]|[-+]?\d|true\b|false\b|null\b|undefined\b)/i.test(expression[1])) add("ANY", path, expression[1], keyIndex);
+    }
+  }
+
+  const call = /(?<!@)\b([\w$]+)\s*\.\s*(get|post|put|patch|delete|head|options|all)\s*\(\s*(["'`])(\/[^"'`]*)\3\s*(?:,\s*([\s\S]{0,160}?))?\)/gi;
+  while ((match = call.exec(scanText))) {
+    const handler = String(match[5] || "").trim();
+    if (!HTTP_CLIENT_CALLER.test(match[1]) && handler && handler[0] !== "{") add(match[2], match[4], match[5], match.index);
+  }
+
+  const go = /\.\s*(?:HandleFunc|Handle)\s*\(\s*(["'`])(\/[^"'`]*)\1\s*,\s*([\s\S]{0,120}?)\)/g;
+  while ((match = go.exec(scanText))) add("ANY", match[2], match[3], match.index);
+
+  if (py || /\.(?:[cm]?[jt]sx?)$/i.test(file)) {
+    const decorator = /@[\w$]*\.?\s*(get|post|put|patch|delete|head|options)\s*\(\s*(["'`])(\/[^"'`]*)\2/gi;
+    while ((match = decorator.exec(scanText))) {
+      const after = scanText.slice(decorator.lastIndex, decorator.lastIndex + 200);
+      const fn = /\b(?:def|async\s+def|function|const|export\s+function)\s+([A-Za-z_$][\w$]*)/.exec(after);
+      add(match[1], match[3], fn ? fn[1] : "", match.index);
+    }
+  }
+  return out;
+}

package/src/analysis/endpoints/inventory.js

@@ -0,0 +1,84 @@
+import { safeRead } from "../../util.js";
+import { createRepoBoundary } from "../../repo-path.js";
+import { MAX_ENDPOINT_FILES, MAX_ENDPOINTS, normalizedFile } from "./common.js";
+import { extractEndpointsFromText, nextRoutePath } from "./extract.js";
+import { joinEndpointPath, mountedBasePaths } from "./mounts.js";
+
+const normParamKey = (path) => String(path).replace(/\{([^/}]+)\}/g, ":$1");
+const sortEndpoints = (left, right) => left.path.localeCompare(right.path) || left.method.localeCompare(right.method);
+
+function preferEndpoint(candidate, current) {
+  if (Boolean(candidate.handler) !== Boolean(current.handler)) return Boolean(candidate.handler);
+  return Number(candidate.path.includes("{")) < Number(current.path.includes("{"));
+}
+
+export function analyzeEndpointInventory(repoPath, codeFiles) {
+  const files = (codeFiles || []).slice(0, MAX_ENDPOINT_FILES);
+  const byKey = new Map();
+  const declarations = new Map();
+  const boundary = createRepoBoundary(repoPath);
+  const sources = new Map();
+  const eligibleFiles = [];
+  for (const file of files) {
+    const relative = normalizedFile(file.path || file);
+    if (!/\.(?:[cm]?[jt]sx?|py|go|rs|java)$/i.test(relative)) continue;
+    const resolved = boundary.resolve(relative);
+    if (!resolved.ok) continue;
+    sources.set(relative, safeRead(resolved.path) || "");
+    eligibleFiles.push(relative);
+  }
+  const mountAnalysis = mountedBasePaths(eligibleFiles, sources);
+  let truncated = false;
+  for (const relative of eligibleFiles) {
+    const text = sources.get(relative);
+    const routeSignal = /["'`]\/|\.(?:get|post|put|patch|delete)\s*\(|HandleFunc|@\w*\.?(?:get|post|put|patch|delete)|@(?:[\w$]+\.)*(?:Request|Get|Post|Put|Patch|Delete)Mapping\b/i;
+    if (!text || (!nextRoutePath(relative) && !routeSignal.test(text))) continue;
+    for (const declaration of extractEndpointsFromText(text, relative)) {
+      const declarationKey = `${declaration.file}\0${declaration.line}\0${declaration.method}\0${normParamKey(declaration.path)}`;
+      if (!declarations.has(declarationKey)) declarations.set(declarationKey, declaration);
+      const bases = mountAnalysis.paths.get(relative) || [{ path: "", chain: [] }];
+      for (const base of bases) {
+        const path = base.path ? joinEndpointPath(base.path, declaration.path) : declaration.path;
+        const endpoint = {
+          ...declaration,
+          declaredPath: declaration.path,
+          path,
+          mountState: base.chain.length ? "COMPOSED_STATIC" : "DECLARED_LOCAL",
+          confidence: base.chain.length ? "high" : "medium",
+          mountChain: base.chain,
+          ...(base.path ? { localPath: declaration.path } : {}),
+        };
+        const key = `${endpoint.method} ${normParamKey(endpoint.path)}`;
+        const current = byKey.get(key);
+        if (!current || preferEndpoint(endpoint, current)) byKey.set(key, endpoint);
+        if (byKey.size >= MAX_ENDPOINTS) { truncated = true; break; }
+      }
+      if (truncated) break;
+    }
+    if (truncated) break;
+  }
+  const endpoints = [...byKey.values()].sort(sortEndpoints);
+  const composed = endpoints.filter((endpoint) => endpoint.mountChain.length).length;
+  return {
+    endpoints,
+    declarations: [...declarations.values()].sort(sortEndpoints),
+    mounts: mountAnalysis.mounts,
+    stats: {
+      scannedFiles: eligibleFiles.length,
+      declaredRoutes: declarations.size,
+      emittedRoutes: endpoints.length,
+      reachableRoutes: composed,
+      reachableStaticRoutes: composed,
+      composedRoutes: composed,
+      localRoutes: endpoints.length - composed,
+      localDeclarations: endpoints.length - composed,
+      staticMounts: mountAnalysis.mounts.length,
+      truncated,
+      maxEndpoints: MAX_ENDPOINTS,
+    },
+  };
+}
+
+export function detectEndpoints(repoPath, codeFiles) {
+  return analyzeEndpointInventory(repoPath, codeFiles).endpoints;
+}

package/src/analysis/endpoints/mounts.js

@@ -0,0 +1,129 @@
+import { posix } from "node:path";
+import { cleanPath, lineAt, maskComments } from "./common.js";
+
+const JS_ROUTE_EXTENSIONS = [".js", ".ts", ".tsx", ".jsx", ".cjs", ".mjs"];
+
+function importBindings(text) {
+  const bindings = new Map();
+  const add = (name, specifier) => {
+    if (/^[A-Za-z_$][\w$]*$/.test(name || "") && typeof specifier === "string") bindings.set(name, specifier);
+  };
+  let match;
+  const direct = /\bimport\s+([A-Za-z_$][\w$]*)\s*(?:,\s*\{[^}]*\})?\s+from\s*(["'`])([^"'`]+)\2/g;
+  while ((match = direct.exec(text))) add(match[1], match[3]);
+  const namespace = /\bimport\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*(["'`])([^"'`]+)\2/g;
+  while ((match = namespace.exec(text))) add(match[1], match[3]);
+  const named = /\bimport\s*\{([^}]+)\}\s*from\s*(["'`])([^"'`]+)\2/g;
+  while ((match = named.exec(text))) {
+    for (const item of match[1].split(",")) {
+      const binding = /^\s*[A-Za-z_$][\w$]*(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*$/.exec(item);
+      if (binding) add(binding[1] || item.trim(), match[3]);
+    }
+  }
+  const commonJs = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*require\s*\(\s*(["'`])([^"'`]+)\2\s*\)/g;
+  while ((match = commonJs.exec(text))) add(match[1], match[3]);
+  return bindings;
+}
+
+function resolveImportedFile(importer, specifier, availableFiles) {
+  if (!specifier?.startsWith(".")) return null;
+  const base = posix.normalize(posix.join(posix.dirname(importer), specifier));
+  const candidates = [base];
+  if (!JS_ROUTE_EXTENSIONS.some((extension) => base.endsWith(extension))) {
+    for (const extension of JS_ROUTE_EXTENSIONS) candidates.push(`${base}${extension}`);
+    for (const extension of JS_ROUTE_EXTENSIONS) candidates.push(`${base}/index${extension}`);
+  }
+  return candidates.find((candidate) => availableFiles.has(candidate)) || null;
+}
+
+function callArguments(text, openParen) {
+  let quote = "", escaped = false, depth = 0, start = openParen + 1;
+  const args = [];
+  for (let index = openParen; index < text.length; index++) {
+    const char = text[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) quote = "";
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") { quote = char; continue; }
+    if (char === "(") { depth++; continue; }
+    if (char === ")") {
+      depth--;
+      if (depth === 0) {
+        args.push(text.slice(start, index).trim());
+        return { args, end: index + 1 };
+      }
+      continue;
+    }
+    if (char === "," && depth === 1) {
+      args.push(text.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  return null;
+}
+
+function routerMounts(text, file, availableFiles) {
+  const scanText = maskComments(text);
+  const bindings = importBindings(scanText);
+  const mounts = [];
+  const useCall = /\b[A-Za-z_$][\w$]*\s*\.\s*use\s*\(/g;
+  let match;
+  while ((match = useCall.exec(scanText))) {
+    const parsed = callArguments(scanText, scanText.indexOf("(", match.index));
+    if (!parsed) continue;
+    useCall.lastIndex = parsed.end;
+    const args = parsed.args.filter(Boolean);
+    if (!args.length) continue;
+    const literal = /^(["'`])(\/[^"'`]*)\1$/.exec(args[0]);
+    const mountPath = literal ? cleanPath(literal[2]) : "/";
+    const identifier = /^([A-Za-z_$][\w$]*)(?:\.[A-Za-z_$][\w$]*)?$/.exec(args.at(-1) || "")?.[1];
+    const child = resolveImportedFile(file, identifier ? bindings.get(identifier) : null, availableFiles);
+    if (child && child !== file) mounts.push({ parent: file, child, path: mountPath, line: lineAt(text, match.index) });
+  }
+  return mounts;
+}
+
+export function joinEndpointPath(base, route) {
+  const left = cleanPath(base || "/");
+  const right = cleanPath(route || "/");
+  if (left === "/") return right;
+  if (right === "/") return left;
+  return cleanPath(`${left}/${right.replace(/^\/+/, "")}`.replace(/\/{2,}/g, "/"));
+}
+
+export function mountedBasePaths(files, sources) {
+  const incoming = new Map();
+  const mounts = [];
+  const available = new Set(files);
+  for (const file of files) {
+    for (const mount of routerMounts(sources.get(file) || "", file, available)) {
+      mounts.push(mount);
+      if (!incoming.has(mount.child)) incoming.set(mount.child, []);
+      incoming.get(mount.child).push(mount);
+    }
+  }
+  const cache = new Map();
+  const resolve = (file, stack = new Set()) => {
+    if (cache.has(file)) return cache.get(file);
+    if (stack.has(file)) return [];
+    const parents = incoming.get(file) || [];
+    if (!parents.length) return [{ path: "", chain: [] }];
+    const paths = [];
+    for (const mount of parents) {
+      for (const base of resolve(mount.parent, new Set(stack).add(file))) {
+        const path = joinEndpointPath(base.path, mount.path);
+        const key = `${path}\0${base.chain.map((item) => `${item.file}:${item.line}:${item.path}`).join("|")}\0${mount.parent}:${mount.line}:${mount.path}`;
+        if (!paths.some((item) => item.key === key)) paths.push({ key, path, chain: [...base.chain, { file: mount.parent, line: mount.line, path: mount.path, child: mount.child }] });
+        if (paths.length >= 32) break;
+      }
+      if (paths.length >= 32) break;
+    }
+    const result = paths.length ? paths.map(({ key: _key, ...item }) => item) : [{ path: "", chain: [] }];
+    cache.set(file, result);
+    return result;
+  };
+  return { paths: new Map(files.map((file) => [file, resolve(file)])), mounts };
+}

package/src/analysis/endpoints-java.js

@@ -4,6 +4,7 @@
 import { maskJavaNonCode } from "./java-source.js";
 
 const SPRING_MAPPING = /@(?:org\.springframework\.web\.bind\.annotation\.)?(RequestMapping|GetMapping|PostMapping|PutMapping|PatchMapping|DeleteMapping)\b/g;
+const SPRING_CONDITION = /@(?:org\.springframework\.boot\.autoconfigure\.condition\.)?(ConditionalOnExpression|ConditionalOnProperty)\b/g;
 const REQUEST_METHOD = /\bRequestMethod\s*\.\s*(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\b/g;
 
 const lineAt = (text, index) => {
@@ -119,6 +120,58 @@ function mappingMethods(name, args) {
   return methods.length ? methods : ["ANY"];
 }
 
+function namedInitializer(args, name) {
+  const source = String(args || "");
+  const match = new RegExp(`\\b${name}\\s*=`).exec(source);
+  return match ? initializer(source, source.indexOf("=", match.index)) : "";
+}
+
+function namedStrings(args, name) {
+  return stringLiterals(namedInitializer(args, name));
+}
+
+function namedBoolean(args, name, fallback) {
+  const value = namedInitializer(args, name).trim();
+  if (/^true\b/i.test(value)) return true;
+  if (/^false\b/i.test(value)) return false;
+  return fallback;
+}
+
+function positionalStrings(args) {
+  const source = String(args || "");
+  const start = source.trimStart()[0];
+  return start === '"' || start === "{" ? stringLiterals(initializer(source, -1)) : [];
+}
+
+function expressionDefaultActive(expression) {
+  const value = String(expression || "").trim();
+  if (/^(?:true|false)$/i.test(value)) return value.toLowerCase() === "true";
+  const match = /^\$\{[^{}:]+:(true|false)\}$/i.exec(value);
+  return match ? match[1].toLowerCase() === "true" : null;
+}
+
+function conditionMetadata(annotation, args) {
+  if (annotation === "ConditionalOnExpression") {
+    const expression = namedStrings(args, "value")[0] || stringLiterals(args)[0] || "";
+    return {
+      type: annotation,
+      expression,
+      defaultActive: expressionDefaultActive(expression),
+    };
+  }
+  const namedProperties = [...namedStrings(args, "name"), ...namedStrings(args, "value")];
+  const properties = [...new Set(namedProperties.length ? namedProperties : positionalStrings(args))];
+  const matchIfMissing = namedBoolean(args, "matchIfMissing", false);
+  return {
+    type: annotation,
+    prefix: namedStrings(args, "prefix")[0] || "",
+    properties,
+    havingValue: namedStrings(args, "havingValue")[0] || "",
+    matchIfMissing,
+    defaultActive: matchIfMissing,
+  };
+}
+
 function joinPaths(prefix, path) {
   const left = String(prefix || "").trim().replace(/^\/+|\/+$/g, "");
   const right = String(path || "").trim().replace(/^\/+|\/+$/g, "");
@@ -135,10 +188,10 @@ function declarationAfter(text, start) {
   if (classMatch) {
     const open = bounded.indexOf("{");
     const bodyOpen = open < 0 ? -1 : declarationStart + open;
-    return { kind: "class", name: classMatch[2], bodyOpen, bodyClose: bodyOpen < 0 ? text.length : balancedEnd(text, bodyOpen, "{", "}") };
+    return { kind: "class", name: classMatch[2], start: declarationStart, bodyOpen, bodyClose: bodyOpen < 0 ? text.length : balancedEnd(text, bodyOpen, "{", "}") };
   }
   const methodMatch = /\b([A-Za-z_$][\w$]*)\s*\(/.exec(head);
-  return methodMatch ? { kind: "method", name: methodMatch[1] } : { kind: "unknown", name: "" };
+  return methodMatch ? { kind: "method", name: methodMatch[1], start: declarationStart } : { kind: "unknown", name: "", start: declarationStart };
 }
 
 export function extractSpringEndpoints(text, file) {
@@ -160,6 +213,19 @@ export function extractSpringEndpoints(text, file) {
     });
     SPRING_MAPPING.lastIndex = Math.max(SPRING_MAPPING.lastIndex, invocation.end);
   }
+  const conditions = [];
+  SPRING_CONDITION.lastIndex = 0;
+  while ((match = SPRING_CONDITION.exec(code))) {
+    const invocation = annotationInvocation(text, SPRING_CONDITION.lastIndex);
+    const declaration = declarationAfter(code, invocation.end);
+    conditions.push({
+      index: match.index,
+      line: lineAt(text, match.index),
+      declaration,
+      ...conditionMetadata(match[1], invocation.args),
+    });
+    SPRING_CONDITION.lastIndex = Math.max(SPRING_CONDITION.lastIndex, invocation.end);
+  }
 
   const classMappings = mappings
     .filter((item) => item.declaration.kind === "class")
@@ -176,9 +242,20 @@ export function extractSpringEndpoints(text, file) {
     const prefixes = owner?.paths?.length ? owner.paths : [""];
     const paths = mappingPaths(item.args);
     if (!paths.length) continue; // literal path was requested but could not be resolved
+    const activationConditions = conditions.filter((condition) => condition.declaration.start === item.declaration.start
+      || (owner && condition.declaration.start === owner.declaration.start));
+    const activation = activationConditions.length
+      ? {
+          conditional: true,
+          defaultActive: activationConditions.some((condition) => condition.defaultActive === false)
+            ? false
+            : activationConditions.every((condition) => condition.defaultActive === true) ? true : null,
+          conditions: activationConditions.map(({ declaration: _declaration, index: _index, ...condition }) => condition),
+        }
+      : {};
     for (const method of mappingMethods(item.annotation, item.args)) {
       for (const prefix of prefixes) for (const path of paths) {
-        out.push({ method, path: joinPaths(prefix, path), handler: item.declaration.name, file, line: item.line });
+        out.push({ method, path: joinPaths(prefix, path), handler: item.declaration.name, file, line: item.line, ...activation });
       }
     }
   }