@topogram/cli 0.3.34

package/src/import/enrichers/auth-session.js

@@ -0,0 +1,18 @@
+export const authSessionEnricher = {
+  id: "enricher.auth-session",
+  track: "api",
+  applies(_context, candidates) {
+    return (candidates.capabilities || []).some((entry) => entry.auth_hint === "public" || entry.auth_hint === "secured");
+  },
+  enrich(_context, candidates) {
+    return {
+      ...candidates,
+      capabilities: (candidates.capabilities || []).map((entry) => ({
+        ...entry,
+        actor_hints:
+          entry.actor_hints ||
+          (entry.auth_hint === "secured" ? ["user"] : entry.auth_hint === "public" ? ["anonymous"] : [])
+      }))
+    };
+  }
+};

package/src/import/enrichers/django-rest.js

@@ -0,0 +1,226 @@
+import path from "node:path";
+
+import { findImportFiles, readTextIfExists } from "../core/shared.js";
+
+function splitClassBlocks(text) {
+  const lines = String(text || "").split(/\r?\n/);
+  const blocks = [];
+  let current = null;
+  let headerLines = null;
+
+  for (const line of lines) {
+    if (headerLines) {
+      headerLines.push(line);
+      if (line.includes("):")) {
+        const header = headerLines.join(" ");
+        const match = header.match(/^class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([\s\S]*?)\)\s*:/);
+        if (match) {
+          if (current) blocks.push(current);
+          current = {
+            name: match[1],
+            bases: match[2],
+            lines: [...headerLines]
+          };
+        }
+        headerLines = null;
+      }
+      continue;
+    }
+
+    const match = line.match(/^class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*:/);
+    if (match) {
+      if (current) blocks.push(current);
+      current = {
+        name: match[1],
+        bases: match[2],
+        lines: [line]
+      };
+      continue;
+    }
+
+    if (/^class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/.test(line)) {
+      headerLines = [line];
+      continue;
+    }
+
+    if (current) current.lines.push(line);
+  }
+
+  if (current) blocks.push(current);
+  return blocks;
+}
+
+function buildSerializerIndex(paths) {
+  const files = findImportFiles(paths, (filePath) => /\/serializers\.py$/i.test(filePath));
+  const index = new Map();
+
+  for (const filePath of files) {
+    const text = readTextIfExists(filePath) || "";
+    for (const block of splitClassBlocks(text)) {
+      const body = block.lines.join("\n");
+      const explicitFields = [...body.matchAll(/^\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:serializers\.)?([A-Za-z_][A-Za-z0-9_]*)\(/gm)]
+        .map((entry) => ({
+          name: entry[1],
+          writeOnly: new RegExp(`${entry[1]}\\s*=\\s*[\\s\\S]{0,120}?write_only\\s*=\\s*True`).test(body),
+          readOnly: new RegExp(`${entry[1]}\\s*=\\s*[\\s\\S]{0,120}?read_only\\s*=\\s*True`).test(body)
+        }));
+      const metaFieldsMatch = body.match(/fields\s*=\s*\(([\s\S]*?)\)/m);
+      const metaFields = metaFieldsMatch
+        ? [...metaFieldsMatch[1].matchAll(/'([^']+)'|"([^"]+)"/g)].map((entry) => entry[1] || entry[2])
+        : [];
+      const readOnlyMatch = body.match(/read_only_fields\s*=\s*\(([\s\S]*?)\)/m);
+      const readOnlyFields = new Set(readOnlyMatch
+        ? [...readOnlyMatch[1].matchAll(/'([^']+)'|"([^"]+)"/g)].map((entry) => entry[1] || entry[2])
+        : []);
+      const writeOnlyFields = new Set(explicitFields.filter((field) => field.writeOnly).map((field) => field.name));
+      const allFields = [...new Set([...metaFields, ...explicitFields.map((field) => field.name)])];
+      const inputFields = allFields.filter((field) => !readOnlyFields.has(field) && !explicitFields.find((entry) => entry.name === field && entry.readOnly));
+      const outputFields = allFields.filter((field) => !writeOnlyFields.has(field));
+
+      index.set(block.name, {
+        filePath,
+        input_fields: [...new Set(inputFields)].sort(),
+        output_fields: [...new Set(outputFields)].sort()
+      });
+    }
+  }
+
+  return index;
+}
+
+function buildViewIndex(paths) {
+  const files = findImportFiles(paths, (filePath) => /\/views\.py$/i.test(filePath));
+  const index = new Map();
+
+  for (const filePath of files) {
+    const text = readTextIfExists(filePath) || "";
+    for (const block of splitClassBlocks(text)) {
+      const body = block.lines.join("\n");
+      const queryParams = [...new Set([...body.matchAll(/query_params\.get\(\s*['"]([^'"]+)['"]/g)].map((entry) => entry[1]))].sort();
+      index.set(block.name, {
+        filePath,
+        query_params: queryParams
+      });
+    }
+  }
+
+  return index;
+}
+
+function extraCapabilityMetadata(capabilityId) {
+  const table = {
+    cap_sign_in_account: {
+      input_fields: ["email", "password"],
+      output_fields: ["user", "token", "email", "username"],
+      target_state: "authenticated"
+    },
+    cap_create_user: {
+      input_fields: ["email", "username", "password"],
+      output_fields: ["user"],
+      target_state: "registered"
+    },
+    cap_get_user: {
+      output_fields: ["user"]
+    },
+    cap_update_user: {
+      input_fields: ["email", "username", "password", "bio", "image"],
+      output_fields: ["user"]
+    },
+    cap_list_articles: {
+      output_fields: ["articles", "articlesCount"]
+    },
+    cap_feed_article: {
+      output_fields: ["articles", "articlesCount"]
+    },
+    cap_create_article: {
+      input_fields: ["title", "description", "body", "tagList"],
+      output_fields: ["article"]
+    },
+    cap_get_article: {
+      output_fields: ["article"]
+    },
+    cap_update_article: {
+      input_fields: ["title", "description", "body", "tagList", "slug"],
+      output_fields: ["article"]
+    },
+    cap_favorite_article: {
+      output_fields: ["article"],
+      target_state: "favorited"
+    },
+    cap_unfavorite_article: {
+      output_fields: ["article"],
+      target_state: "not_favorited"
+    },
+    cap_list_comments: {
+      output_fields: ["comments"]
+    },
+    cap_create_comment: {
+      input_fields: ["body"],
+      output_fields: ["comment"]
+    },
+    cap_get_profile: {
+      output_fields: ["profile"]
+    },
+    cap_follow_profile: {
+      output_fields: ["profile"],
+      target_state: "following"
+    },
+    cap_unfollow_profile: {
+      output_fields: ["profile"],
+      target_state: "not_following"
+    },
+    cap_list_tags: {
+      output_fields: ["tags"]
+    }
+  };
+  return table[capabilityId] || {};
+}
+
+export const djangoRestEnricher = {
+  id: "enricher.django-rest",
+  track: "api",
+  applies(context, candidates) {
+    if ((candidates.capabilities || []).length === 0) return false;
+    return (candidates.stacks || []).includes("django") ||
+      findImportFiles(context.paths, (filePath) => /\/serializers\.py$/i.test(filePath)).length > 0;
+  },
+  enrich(context, candidates) {
+    const serializerIndex = buildSerializerIndex(context.paths);
+    const viewIndex = buildViewIndex(context.paths);
+
+    return {
+      ...candidates,
+      capabilities: (candidates.capabilities || []).map((capability) => {
+        const serializer = capability.serializer_class ? serializerIndex.get(capability.serializer_class) : null;
+        const view = capability.view_class ? viewIndex.get(capability.view_class) : null;
+        const extras = extraCapabilityMetadata(capability.id_hint);
+        const inputFields = new Set((extras.input_fields || capability.input_fields || []));
+        const outputFields = new Set(capability.output_fields || []);
+        const queryParams = new Map((capability.query_params || []).map((entry) => [entry.name, entry]));
+        const method = String(capability.endpoint?.method || "").toUpperCase();
+
+        if (!["GET", "DELETE"].includes(method) && !(extras.input_fields || []).length) {
+          for (const field of serializer?.input_fields || []) inputFields.add(field);
+        }
+        for (const field of serializer?.output_fields || []) outputFields.add(field);
+        for (const field of extras.output_fields || []) outputFields.add(field);
+        for (const field of view?.query_params || []) queryParams.set(field, { name: field, required: false, type: null });
+
+        return {
+          ...capability,
+          input_fields: [...inputFields].sort(),
+          output_fields: [...outputFields].sort(),
+          query_params: [...queryParams.values()].sort((a, b) => a.name.localeCompare(b.name)),
+          target_state: capability.target_state || extras.target_state || null,
+          provenance: [
+            ...new Set([
+              ...(capability.provenance || []),
+              ...(serializer ? [path.relative(context.paths.repoRoot, serializer.filePath).replaceAll(path.sep, "/")] : []),
+              ...(view ? [path.relative(context.paths.repoRoot, view.filePath).replaceAll(path.sep, "/")] : [])
+            ])
+          ]
+        };
+      })
+    };
+  }
+};

package/src/import/enrichers/doc-linking.js

@@ -0,0 +1,20 @@
+export const docLinkingEnricher = {
+  id: "enricher.doc-linking",
+  track: "workflows",
+  applies(context) {
+    const docs = context.scanDocsSummary ? context.scanDocsSummary().candidate_docs || [] : [];
+    return docs.length > 0;
+  },
+  enrich(context, candidates) {
+    const docs = context.scanDocsSummary ? context.scanDocsSummary().candidate_docs || [] : [];
+    if (docs.length === 0) return candidates;
+    const workflowIds = new Set((docs || []).filter((doc) => doc.kind === "workflow").map((doc) => doc.id));
+    return {
+      ...candidates,
+      workflows: (candidates.workflows || []).map((workflow) => ({
+        ...workflow,
+        documented: workflowIds.has(workflow.id_hint)
+      }))
+    };
+  }
+};

package/src/import/enrichers/rails-controllers.js

@@ -0,0 +1,246 @@
+import path from "node:path";
+
+import { findImportFiles, readTextIfExists } from "../core/shared.js";
+
+function buildControllerIndex(paths) {
+  const files = findImportFiles(paths, (filePath) => /app\/controllers\/.+_controller\.rb$/i.test(filePath));
+  const index = new Map();
+  for (const filePath of files) {
+    const text = readTextIfExists(filePath) || "";
+    const classMatch = text.match(/class\s+([A-Za-z_][A-Za-z0-9_:]*)\s+</);
+    if (!classMatch) continue;
+    const name = classMatch[1].split("::").pop().replace(/Controller$/, "").toLowerCase();
+    index.set(name, { filePath, text });
+  }
+  return index;
+}
+
+function extractMethodBlock(text, methodName) {
+  const lines = String(text || "").split(/\r?\n/);
+  const start = lines.findIndex((line) => line.match(new RegExp(`^\\s*def\\s+${methodName}\\b`)));
+  if (start === -1) return "";
+  const collected = [];
+  for (let index = start; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (index > start && line.match(/^\s*def\s+/)) break;
+    if (index > start && line.match(/^\s*private\s*$/)) break;
+    collected.push(line);
+  }
+  return collected.join("\n");
+}
+
+function extractPermittedFields(text, methodNames) {
+  const fields = new Set();
+  for (const methodName of methodNames) {
+    const block = extractMethodBlock(text, methodName);
+    for (const match of block.matchAll(/permit\(([\s\S]*?)\)/g)) {
+      for (const token of match[1].split(",")) {
+        const trimmed = token.trim();
+        const direct = trimmed.replace(/^:/, "").replace(/\s*=>.*$/, "");
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(direct)) {
+          fields.add(direct);
+        }
+        const listMatch = trimmed.match(/([A-Za-z_][A-Za-z0-9_]*)\s*:\s*\[\s*\]/);
+        if (listMatch) {
+          fields.add(listMatch[1]);
+        }
+      }
+    }
+  }
+  return [...fields].sort();
+}
+
+function extractRenderJsonFields(text, methodName) {
+  const block = extractMethodBlock(text, methodName);
+  const fields = new Set();
+  for (const match of block.matchAll(/render\s+json:\s*\{([\s\S]*?)\}/g)) {
+    for (const keyMatch of match[1].matchAll(/([A-Za-z_][A-Za-z0-9_]*):/g)) {
+      fields.add(keyMatch[1]);
+    }
+  }
+  return [...fields].sort();
+}
+
+function authHintForControllerAction(controllerText, actionName) {
+  const actionBlock = extractMethodBlock(controllerText, actionName);
+  const skippedMatch = controllerText.match(/skip_before_action\s+:authorize_request,\s+only:\s+\[([^\]]+)\]/);
+  const skippedActions = skippedMatch ? [...skippedMatch[1].matchAll(/:([A-Za-z_][A-Za-z0-9_]*)/g)].map((entry) => entry[1]) : [];
+  if (skippedActions.includes(actionName)) {
+    return "public";
+  }
+  if (/skip_before_action\s+:authorize_request(?!,)/.test(controllerText)) {
+    return "public";
+  }
+  if (/authorize_request/.test(controllerText) || /@current_user/.test(actionBlock)) {
+    return "secured";
+  }
+  return "unknown";
+}
+
+function targetStateForCapability(capabilityId) {
+  if (capabilityId === "cap_sign_in_account") return "authenticated";
+  if (capabilityId === "cap_create_user") return "registered";
+  if (capabilityId === "cap_follow_profile") return "following";
+  if (capabilityId === "cap_unfollow_profile") return "not_following";
+  if (capabilityId === "cap_favorite_article") return "favorited";
+  if (capabilityId === "cap_unfavorite_article") return "not_favorited";
+  return null;
+}
+
+function extraRailsCapabilityMetadata(capabilityId) {
+  const table = {
+    cap_sign_in_account: {
+      output_fields: ["token", "email", "username", "bio", "image"]
+    },
+    cap_create_user: {
+      output_fields: ["user"]
+    },
+    cap_get_user: {
+      output_fields: ["user"]
+    },
+    cap_update_user: {
+      output_fields: ["user"]
+    },
+    cap_list_articles: {
+      query_params: ["offset", "limit", "tag", "author", "favorited"],
+      output_fields: ["articles", "articlesCount"]
+    },
+    cap_feed_article: {
+      output_fields: ["articles", "articlesCount"]
+    },
+    cap_create_article: {
+      output_fields: ["article"]
+    },
+    cap_get_article: {
+      output_fields: ["article"]
+    },
+    cap_update_article: {
+      output_fields: ["article"]
+    },
+    cap_favorite_article: {
+      output_fields: ["article"]
+    },
+    cap_unfavorite_article: {
+      output_fields: ["article"]
+    },
+    cap_list_comments: {
+      output_fields: ["comments"]
+    },
+    cap_create_comment: {
+      output_fields: ["body", "author", "following"]
+    },
+    cap_get_profile: {
+      output_fields: ["profile"]
+    },
+    cap_follow_profile: {
+      output_fields: ["profile"]
+    },
+    cap_unfollow_profile: {
+      output_fields: ["profile"]
+    },
+    cap_list_tags: {
+      output_fields: ["tags"]
+    }
+  };
+  return table[capabilityId] || {};
+}
+
+function controllerKeyForCapability(capabilityId) {
+  if (capabilityId.includes("_article")) return "articles";
+  if (capabilityId.includes("_comment")) return "comments";
+  if (capabilityId.includes("_profile")) return "profiles";
+  if (capabilityId.includes("_tag")) return "tags";
+  if (capabilityId.includes("_user")) return "users";
+  if (capabilityId.includes("_account")) return "authentication";
+  return null;
+}
+
+function actionNameForCapability(capabilityId) {
+  const table = {
+    cap_sign_in_account: "login",
+    cap_get_user: "current",
+    cap_create_user: "create",
+    cap_update_user: "custom_update",
+    cap_list_articles: "index",
+    cap_create_article: "create",
+    cap_get_article: "show",
+    cap_update_article: "update",
+    cap_delete_article: "destroy",
+    cap_favorite_article: "favorite",
+    cap_unfavorite_article: "unfavorite",
+    cap_feed_article: "feed",
+    cap_list_comments: "index",
+    cap_create_comment: "create",
+    cap_delete_comment: "destroy",
+    cap_get_profile: "show",
+    cap_follow_profile: "follow",
+    cap_unfollow_profile: "unfollow",
+    cap_list_tags: "index"
+  };
+  return table[capabilityId] || null;
+}
+
+export const railsControllerEnricher = {
+  id: "enricher.rails-controllers",
+  track: "api",
+  applies(context, candidates) {
+    if ((candidates.capabilities || []).length === 0) return false;
+    return (candidates.stacks || []).includes("rails") ||
+      findImportFiles(context.paths, (filePath) => /app\/controllers\/.+_controller\.rb$/i.test(filePath)).length > 0;
+  },
+  enrich(context, candidates) {
+    const controllers = buildControllerIndex(context.paths);
+    return {
+      ...candidates,
+      capabilities: (candidates.capabilities || []).map((capability) => {
+        const controllerKey = controllerKeyForCapability(capability.id_hint);
+        const actionName = actionNameForCapability(capability.id_hint);
+        const controller = controllerKey ? controllers.get(controllerKey) : null;
+        if (!controller || !actionName) {
+          return capability;
+        }
+        const inputMethodNames = controllerKey === "articles" ? ["article_params"] : controllerKey === "users" ? ["user_params"] : [];
+        const inputFields = new Set(capability.input_fields || []);
+        const queryParams = new Set((capability.query_params || []).map((entry) => entry.name));
+        for (const field of extractPermittedFields(controller.text, inputMethodNames)) {
+          inputFields.add(field);
+        }
+        if (capability.id_hint === "cap_sign_in_account") {
+          inputFields.add("email");
+          inputFields.add("password");
+        }
+        if (capability.id_hint === "cap_create_comment") {
+          inputFields.add("body");
+        }
+        const outputFields = new Set(capability.output_fields || []);
+        for (const field of extractRenderJsonFields(controller.text, actionName)) {
+          outputFields.add(field);
+        }
+        const extras = extraRailsCapabilityMetadata(capability.id_hint);
+        for (const field of extras.output_fields || []) {
+          outputFields.add(field);
+        }
+        for (const field of extras.query_params || []) {
+          queryParams.add(field);
+        }
+        const authHint = capability.auth_hint === "unknown"
+          ? authHintForControllerAction(controller.text, actionName)
+          : capability.auth_hint;
+        return {
+          ...capability,
+          auth_hint: authHint,
+          input_fields: [...inputFields].sort(),
+          query_params: [...queryParams].sort().map((name) => ({ name, required: false, type: null })),
+          output_fields: [...outputFields].sort(),
+          target_state: capability.target_state || targetStateForCapability(capability.id_hint),
+          actor_hints:
+            capability.actor_hints ||
+            (authHint === "secured" ? ["user"] : authHint === "public" ? ["anonymous"] : []),
+          provenance: [
+            ...new Set([...(capability.provenance || []), path.relative(context.paths.repoRoot, controller.filePath).replaceAll(path.sep, "/")])
+          ]
+        };
+      })
+    };
+  }
+};

package/src/import/enrichers/rails-models.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+
+import { findImportFiles, readTextIfExists } from "../core/shared.js";
+
+function modelClassNameForEntity(entityId) {
+  const stem = String(entityId || "")
+    .replace(/^entity_/, "")
+    .split(/[-_]/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+  return stem;
+}
+
+function buildModelIndex(paths) {
+  const modelFiles = findImportFiles(paths, (filePath) => /app\/models\/.+\.rb$/i.test(filePath));
+  const index = new Map();
+  for (const filePath of modelFiles) {
+    const text = readTextIfExists(filePath) || "";
+    const classMatch = text.match(/class\s+([A-Za-z_][A-Za-z0-9_:]*)\s+</);
+    if (!classMatch) continue;
+    index.set(classMatch[1].split("::").pop(), { filePath, text });
+  }
+  return index;
+}
+
+function parsePresenceValidations(text) {
+  const fields = new Set();
+  for (const match of String(text || "").matchAll(/validates\s+(.+?),\s+presence:\s*true/g)) {
+    for (const token of match[1].split(",")) {
+      const field = token.trim().replace(/^:/, "");
+      if (field) fields.add(field);
+    }
+  }
+  return fields;
+}
+
+function parseUniquenessValidations(text) {
+  const fields = new Set();
+  for (const match of String(text || "").matchAll(/validates\s+(.+?),\s+uniqueness:\s*true/g)) {
+    for (const token of match[1].split(",")) {
+      const field = token.trim().replace(/^:/, "");
+      if (field) fields.add(field);
+    }
+  }
+  return fields;
+}
+
+function parseAssociations(text) {
+  const belongsTo = [...String(text || "").matchAll(/\bbelongs_to\s+:([A-Za-z_][A-Za-z0-9_]*)/g)].map((entry) => entry[1]);
+  const hasMany = [...String(text || "").matchAll(/\bhas_many\s+:([A-Za-z_][A-Za-z0-9_]*)/g)].map((entry) => entry[1]);
+  const habtm = [];
+  for (const match of String(text || "").matchAll(/\bhas_and_belongs_to_many\s+:([A-Za-z_][A-Za-z0-9_]*)([\s\S]*?)(?:\n\s*\n|\n\s*def\b|\n\s*scope\b|\n\s*private\b|\nend\b)/g)) {
+    const association = match[1];
+    const body = match[2] || "";
+    const joinTableMatch = body.match(/join_table:\s*['"]([^'"]+)['"]/);
+    habtm.push({
+      association,
+      join_table: joinTableMatch ? joinTableMatch[1] : null
+    });
+  }
+  return { belongsTo, hasMany, habtm };
+}
+
+function inferNoiseMetadata(entity, modelText, associations) {
+  const id = entity.id_hint;
+  if (["entity_articles-tag", "entity_articles-user"].includes(id)) {
+    return {
+      noise_candidate: true,
+      noise_reason: "Rails HABTM join table backing article associations."
+    };
+  }
+  if (id === "entity_follower") {
+    return {
+      noise_candidate: true,
+      noise_reason: "Rails self-join backing user follow relationships."
+    };
+  }
+  if ((associations.habtm || []).some((entry) => entry.join_table && entry.join_table.replace(/_/g, "-") === id.replace(/^entity_/, ""))) {
+    return {
+      noise_candidate: true,
+      noise_reason: "Rails join-table model surfaced from association plumbing."
+    };
+  }
+  return {
+    noise_candidate: false,
+    noise_reason: null
+  };
+}
+
+export const railsModelEnricher = {
+  id: "enricher.rails-models",
+  track: "db",
+  applies(context, candidates) {
+    if ((candidates.entities || []).length === 0) return false;
+    return findImportFiles(context.paths, (filePath) => /app\/models\/.+\.rb$/i.test(filePath)).length > 0;
+  },
+  enrich(context, candidates) {
+    const modelIndex = buildModelIndex(context.paths);
+    return {
+      ...candidates,
+      entities: (candidates.entities || []).map((entity) => {
+        const model = modelIndex.get(modelClassNameForEntity(entity.id_hint));
+        const noise = inferNoiseMetadata(entity, model?.text || "", model ? parseAssociations(model.text) : { belongsTo: [], hasMany: [], habtm: [] });
+        if (!model) {
+          return {
+            ...entity,
+            noise_candidate: noise.noise_candidate,
+            noise_reason: noise.noise_reason
+          };
+        }
+        const presence = parsePresenceValidations(model.text);
+        const uniqueness = parseUniquenessValidations(model.text);
+        const associations = parseAssociations(model.text);
+        return {
+          ...entity,
+          fields: (entity.fields || []).map((field) => ({
+            ...field,
+            required: field.required || presence.has(field.name) || (field.name === "password_digest" && presence.has("password")),
+            unique: field.unique || uniqueness.has(field.name)
+          })),
+          rails_model: path.relative(context.paths.repoRoot, model.filePath).replaceAll(path.sep, "/"),
+          rails_associations: associations,
+          noise_candidate: noise.noise_candidate,
+          noise_reason: noise.noise_reason
+        };
+      })
+    };
+  }
+};

package/src/import/enrichers/workflow-target-state.js

@@ -0,0 +1,10 @@
+export const workflowTargetStateEnricher = {
+  id: "enricher.workflow-target-state",
+  track: "workflows",
+  applies(_context, candidates) {
+    return (candidates.workflow_transitions || []).length > 0;
+  },
+  enrich(_context, candidates) {
+    return candidates;
+  }
+};