@topogram/cli 0.3.34

package/src/import/extractors/api/express.js

@@ -0,0 +1,154 @@
+import path from "node:path";
+
+import {
+  dedupeCandidateRecords,
+  findImportFiles,
+  inferApiEntityIdFromPath,
+  inferRouteAuthHint,
+  inferRouteCapabilityId,
+  inferRouteQueryParams,
+  makeCandidateRecord,
+  normalizeOpenApiPath,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function parseApiRoutesMap(text) {
+  const match = text.match(/export\s+const\s+API_ROUTES\s*=\s*\{([\s\S]*?)\}\s*as\s+const/);
+  if (!match) return {};
+  const entries = {};
+  for (const entry of match[1].split(/\r?\n/)) {
+    const line = entry.trim().replace(/,$/, "");
+    const routeMatch = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*["'`]([^"'`]+)["'`]$/);
+    if (routeMatch) {
+      entries[routeMatch[1]] = routeMatch[2];
+    }
+  }
+  return entries;
+}
+
+function parsePermissionsMetadata(text) {
+  const entries = new Map();
+  for (const match of text.matchAll(/permissions\.set\(\s*API_ROUTES\.([A-Za-z_][A-Za-z0-9_]*)\s*,\s*\{([\s\S]*?)\}\s*\)/g)) {
+    const routeKey = match[1];
+    const body = match[2];
+    entries.set(routeKey, {
+      authenticated: /authenticated:\s*true/.test(body),
+      super: /super:\s*true/.test(body)
+    });
+  }
+  return entries;
+}
+
+function extractHandlerContext(text, handlerName) {
+  if (!handlerName) return "";
+  const escaped = handlerName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const pattern of [
+    new RegExp(`function\\s+${escaped}\\s*\\([^)]*\\)\\s*\\{([\\s\\S]{0,1200}?)\\n\\}`, "m"),
+    new RegExp(`const\\s+${escaped}\\s*=\\s*(?:async\\s*)?\\([^)]*\\)\\s*=>\\s*\\{([\\s\\S]{0,1200}?)\\n\\}`, "m")
+  ]) {
+    const match = text.match(pattern);
+    if (match) return match[1];
+  }
+  return "";
+}
+
+function parseExpressRouteCalls(filePath, text, apiRoutes, permissionMeta) {
+  const routes = [];
+  for (const match of text.matchAll(/app\.(get|post|put|patch|delete)\(\s*([^,]+?)\s*,([\s\S]*?)\)\s*;?/g)) {
+    const method = match[1].toUpperCase();
+    const rawPath = match[2].trim();
+    const args = match[3];
+    let routePath = null;
+    let routeKey = null;
+    const apiRouteRef = rawPath.match(/^API_ROUTES\.([A-Za-z_][A-Za-z0-9_]*)$/);
+    if (apiRouteRef) {
+      routeKey = apiRouteRef[1];
+      routePath = apiRoutes[routeKey] || null;
+    } else {
+      routePath = rawPath.replace(/^["'`]|["'`]$/g, "");
+    }
+    if (!routePath) continue;
+    const handlerNames = [...args.matchAll(/\b([A-Za-z_][A-Za-z0-9_]*)\b/g)].map((entry) => entry[1]);
+    const filtered = handlerNames.filter((name) => !["app", "get", "post", "put", "patch", "delete"].includes(name));
+    const handlerHint = filtered.length > 0 ? filtered[filtered.length - 1] : null;
+    const handlerContext = extractHandlerContext(text, handlerHint);
+    const meta = routeKey ? permissionMeta.get(routeKey) : null;
+    routes.push({
+      file: filePath,
+      method,
+      path: routePath,
+      handler_hint: handlerHint,
+      path_params: [...routePath.matchAll(/:([A-Za-z_][A-Za-z0-9_]*)/g)].map((entry) => entry[1]),
+      query_params: inferRouteQueryParams(handlerContext),
+      auth_hint:
+        meta?.super || meta?.authenticated
+          ? "secured"
+          : inferRouteAuthHint(args, handlerContext)
+    });
+  }
+  return routes;
+}
+
+export const expressExtractor = {
+  id: "api.express",
+  track: "api",
+  detect(context) {
+    const routeFiles = findImportFiles(context.paths, (filePath) => /src\/routes\/.+\.(ts|js|mjs|cjs)$/i.test(filePath));
+    return {
+      score: routeFiles.length > 0 ? 85 : 0,
+      reasons: routeFiles.length > 0 ? ["Found Express route modules"] : []
+    };
+  },
+  extract(context) {
+    const permissionsFile = findImportFiles(context.paths, (filePath) => /src\/helpers\/permissions\.(ts|js|mjs|cjs)$/i.test(filePath))[0];
+    const permissionsText = permissionsFile ? context.helpers.readTextIfExists(permissionsFile) || "" : "";
+    const apiRoutes = parseApiRoutesMap(permissionsText);
+    const permissionMeta = parsePermissionsMetadata(permissionsText);
+    const routeFiles = findImportFiles(context.paths, (filePath) => /src\/routes\/.+\.(ts|js|mjs|cjs)$/i.test(filePath));
+    const routes = routeFiles.flatMap((filePath) =>
+      parseExpressRouteCalls(filePath, context.helpers.readTextIfExists(filePath) || "", apiRoutes, permissionMeta)
+    );
+    const findings = [];
+    const candidates = { capabilities: [], routes: [], stacks: [] };
+    if (routes.length > 0) {
+      findings.push({
+        kind: "express_routes",
+        files: [...new Set(routes.map((route) => relativeTo(context.paths.repoRoot, route.file)))],
+        route_count: routes.length
+      });
+      candidates.capabilities.push(...routes.map((route) => makeCandidateRecord({
+        kind: "capability",
+        idHint: inferRouteCapabilityId(route),
+        label: route.handler_hint ? titleCase(route.handler_hint) : `${route.method} ${route.path}`,
+        confidence: "high",
+        sourceKind: "route_code",
+        provenance: `${relativeTo(context.paths.repoRoot, route.file)}#${route.method} ${route.path}`,
+        endpoint: { method: route.method, path: normalizeOpenApiPath(route.path) },
+        path_params: (route.path_params || []).map((name) => ({ name, required: true, type: null })),
+        query_params: (route.query_params || []).map((name) => ({ name, required: false, type: null })),
+        header_params: [],
+        input_fields: [],
+        output_fields: [],
+        auth_hint: route.auth_hint || "unknown",
+        entity_id: inferApiEntityIdFromPath(route.path),
+        track: "api"
+      })));
+      candidates.routes.push(...routes.map((route) => ({
+        path: normalizeOpenApiPath(route.path),
+        method: route.method,
+        confidence: "high",
+        source_kind: "route_code",
+        provenance: `${relativeTo(context.paths.repoRoot, route.file)}#${route.method} ${route.path}`
+      })));
+      candidates.stacks.push("express");
+    }
+    candidates.capabilities = dedupeCandidateRecords(candidates.capabilities, (record) => record.id_hint);
+    candidates.routes = dedupeCandidateRecords(
+      candidates.routes.map((route) => ({ ...route, id_hint: `${route.method}_${route.path}` })),
+      (record) => `${record.method}:${record.path}:${record.source_kind}`
+    ).map(({ id_hint, ...route }) => route);
+    candidates.stacks = [...new Set(candidates.stacks)].sort();
+    return { findings, candidates };
+  }
+};

package/src/import/extractors/api/fastify.js

@@ -0,0 +1,371 @@
+import path from "node:path";
+
+import {
+  dedupeCandidateRecords,
+  findImportFiles,
+  inferApiCapabilityIdFromOperation,
+  inferApiEntityIdFromPath,
+  makeCandidateRecord,
+  normalizeOpenApiPath,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function splitTopLevelProperties(block) {
+  const props = [];
+  let current = "";
+  let depth = 0;
+  let inString = false;
+  let quote = null;
+  for (let i = 0; i < block.length; i += 1) {
+    const ch = block[i];
+    const prev = block[i - 1];
+    if (inString) {
+      current += ch;
+      if (ch === quote && prev !== "\\") {
+        inString = false;
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      inString = true;
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") {
+      depth += 1;
+      current += ch;
+      continue;
+    }
+    if (ch === "}" || ch === "]" || ch === ")") {
+      depth -= 1;
+      current += ch;
+      continue;
+    }
+    if (ch === "," && depth === 0) {
+      if (current.trim()) props.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) props.push(current.trim());
+  return props;
+}
+
+function extractBalanced(text, openIndex, openChar, closeChar) {
+  let depth = 0;
+  let inString = false;
+  let quote = null;
+  for (let i = openIndex; i < text.length; i += 1) {
+    const ch = text[i];
+    const prev = text[i - 1];
+    if (inString) {
+      if (ch === quote && prev !== "\\") {
+        inString = false;
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      inString = true;
+      quote = ch;
+      continue;
+    }
+    if (ch === openChar) {
+      depth += 1;
+    } else if (ch === closeChar) {
+      depth -= 1;
+      if (depth === 0) {
+        return text.slice(openIndex, i + 1);
+      }
+    }
+  }
+  return null;
+}
+
+function findCallArguments(text, calleePattern) {
+  const calls = [];
+  for (const match of text.matchAll(calleePattern)) {
+    const openIndex = text.indexOf("(", match.index);
+    if (openIndex < 0) continue;
+    const callText = extractBalanced(text, openIndex, "(", ")");
+    if (!callText) continue;
+    const inner = callText.slice(1, -1);
+    calls.push({
+      method: match[1].toUpperCase(),
+      args: splitTopLevelProperties(inner)
+    });
+  }
+  return calls;
+}
+
+function parseNamedTypeboxSchemas(schemaFiles, readText) {
+  const schemas = new Map();
+  for (const filePath of schemaFiles) {
+    const text = readText(filePath) || "";
+    for (const match of text.matchAll(/export\s+const\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*Type\.Object\s*\(/g)) {
+      const openParenIndex = text.indexOf("(", match.index);
+      const objectCall = extractBalanced(text, openParenIndex, "(", ")");
+      if (!objectCall) continue;
+      const firstBraceIndex = objectCall.indexOf("{");
+      if (firstBraceIndex < 0) continue;
+      const objectBlock = extractBalanced(objectCall, firstBraceIndex, "{", "}");
+      if (!objectBlock) continue;
+      schemas.set(match[1], objectBlock);
+    }
+  }
+  return schemas;
+}
+
+function parseSchemaExpressionFields(expression, namedSchemas, seen = new Set()) {
+  const value = String(expression || "").trim();
+  if (!value) return [];
+
+  const identifierMatch = value.match(/^([A-Za-z_][A-Za-z0-9_]*)$/);
+  if (identifierMatch) {
+    const schemaName = identifierMatch[1];
+    if (seen.has(schemaName)) return [];
+    if (namedSchemas.has(schemaName)) {
+      return parseSchemaExpressionFields(namedSchemas.get(schemaName), namedSchemas, new Set([...seen, schemaName]));
+    }
+    return [];
+  }
+
+  if ((value.startsWith("{") && value.endsWith("}"))) {
+    const fields = [];
+    for (const prop of splitTopLevelProperties(value.slice(1, -1))) {
+      const propMatch = prop.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:/);
+      if (propMatch) fields.push(propMatch[1]);
+    }
+    return [...new Set(fields)].sort();
+  }
+
+  const typeObjectMatch = value.match(/^Type\.Object\s*\(/);
+  if (typeObjectMatch) {
+    const firstBraceIndex = value.indexOf("{");
+    if (firstBraceIndex < 0) return [];
+    const objectBlock = extractBalanced(value, firstBraceIndex, "{", "}");
+    if (!objectBlock) return [];
+    return parseSchemaExpressionFields(objectBlock, namedSchemas, seen);
+  }
+
+  const arrayMatch = value.match(/^Type\.(Array|Optional)\s*\(([\s\S]*)\)$/);
+  if (arrayMatch) {
+    return parseSchemaExpressionFields(arrayMatch[2], namedSchemas, seen);
+  }
+
+  return [];
+}
+
+function parseSchemaBlock(optionsArg) {
+  const schemaKeyIndex = optionsArg.indexOf("schema:");
+  if (schemaKeyIndex < 0) return null;
+  const braceIndex = optionsArg.indexOf("{", schemaKeyIndex);
+  if (braceIndex < 0) return null;
+  return extractBalanced(optionsArg, braceIndex, "{", "}");
+}
+
+function parseSchemaEntryExpression(schemaBlock, entryName) {
+  const match = schemaBlock.match(new RegExp(`${entryName}\\s*:\\s*`, "m"));
+  if (!match || typeof match.index !== "number") return null;
+  const start = match.index + match[0].length;
+  let i = start;
+  while (i < schemaBlock.length && /\s/.test(schemaBlock[i])) i += 1;
+  if (i >= schemaBlock.length) return null;
+  const ch = schemaBlock[i];
+  if (ch === "{") {
+    return extractBalanced(schemaBlock, i, "{", "}");
+  }
+  if (/[A-Za-z_]/.test(ch)) {
+    let j = i;
+    let depth = 0;
+    let inString = false;
+    let quote = null;
+    for (; j < schemaBlock.length; j += 1) {
+      const current = schemaBlock[j];
+      const prev = schemaBlock[j - 1];
+      if (inString) {
+        if (current === quote && prev !== "\\") {
+          inString = false;
+          quote = null;
+        }
+        continue;
+      }
+      if (current === "'" || current === '"' || current === "`") {
+        inString = true;
+        quote = current;
+        continue;
+      }
+      if (current === "(" || current === "{" || current === "[") {
+        depth += 1;
+      } else if (current === ")" || current === "}" || current === "]") {
+        depth -= 1;
+      } else if ((current === "," || current === "\n") && depth <= 0) {
+        break;
+      }
+    }
+    return schemaBlock.slice(i, j).trim().replace(/,$/, "");
+  }
+  return null;
+}
+
+function parseResponseExpression(schemaBlock) {
+  const responseExpression = parseSchemaEntryExpression(schemaBlock, "response");
+  if (!responseExpression) return null;
+  if (!(responseExpression.startsWith("{") && responseExpression.endsWith("}"))) {
+    return responseExpression;
+  }
+  const preferredCodes = ["200", "201", "202", "204"];
+  const entries = splitTopLevelProperties(responseExpression.slice(1, -1));
+  for (const code of preferredCodes) {
+    const entry = entries.find((prop) => prop.trim().startsWith(`${code}:`));
+    if (!entry) continue;
+    const value = entry.slice(entry.indexOf(":") + 1).trim();
+    if (!value) continue;
+    if (value.startsWith("{")) {
+      return value;
+    }
+    return value;
+  }
+  return null;
+}
+
+function parseTags(schemaBlock) {
+  const tagsMatch = schemaBlock.match(/tags\s*:\s*\[([^\]]*)\]/m);
+  if (!tagsMatch) return [];
+  return tagsMatch[1]
+    .split(",")
+    .map((tag) => tag.trim().replace(/^["'`]|["'`]$/g, ""))
+    .filter(Boolean);
+}
+
+function joinRoutePath(basePath, localPath) {
+  const full = `${basePath === "/" ? "" : basePath}${localPath === "/" ? "" : localPath}` || "/";
+  return normalizeOpenApiPath(full.startsWith("/") ? full : `/${full}`);
+}
+
+function inferBasePath(apiRoutesRoot, filePath) {
+  const relativeDir = path.relative(apiRoutesRoot, path.dirname(filePath)).replaceAll(path.sep, "/");
+  if (!relativeDir || relativeDir === ".") return "/";
+  return `/${relativeDir}`;
+}
+
+function inferFastifyAuthHint(routePath, optionsArg) {
+  if (routePath === "/auth/login" || routePath === "/auth/register") return "public";
+  if (/preHandler\s*:/.test(optionsArg)) return "secured";
+  return "secured";
+}
+
+export const fastifyExtractor = {
+  id: "api.fastify",
+  track: "api",
+  detect(context) {
+    const routeFiles = findImportFiles(context.paths, (filePath) => /src\/routes\/api\/.+\.(ts|js|mjs|cjs)$/i.test(filePath));
+    const packageJsonFiles = findImportFiles(context.paths, (filePath) => /package\.json$/i.test(filePath));
+    const hasFastifyDependency = packageJsonFiles.some((filePath) => /"fastify"\s*:/.test(context.helpers.readTextIfExists(filePath) || ""));
+    return {
+      score: routeFiles.length > 0 && hasFastifyDependency ? 86 : 0,
+      reasons: routeFiles.length > 0 && hasFastifyDependency ? ["Found Fastify route plugins and Fastify package dependency"] : []
+    };
+  },
+  extract(context) {
+    const apiRoutesRoot = findImportFiles(context.paths, (filePath) => /src\/routes\/api\/index\.(ts|js|mjs|cjs)$/i.test(filePath))[0]
+      ? path.join(path.dirname(findImportFiles(context.paths, (filePath) => /src\/routes\/api\/index\.(ts|js|mjs|cjs)$/i.test(filePath))[0]))
+      : null;
+    if (!apiRoutesRoot) {
+      return { findings: [], candidates: { capabilities: [], routes: [], stacks: [] } };
+    }
+
+    const routeFiles = findImportFiles(context.paths, (filePath) => /src\/routes\/api\/.+\.(ts|js|mjs|cjs)$/i.test(filePath))
+      .filter((filePath) => !/\/autohooks\.(ts|js|mjs|cjs)$/i.test(filePath));
+    const schemaFiles = findImportFiles(context.paths, (filePath) => /src\/schemas\/.+\.(ts|js|mjs|cjs)$/i.test(filePath));
+    const namedSchemas = parseNamedTypeboxSchemas(schemaFiles, context.helpers.readTextIfExists);
+
+    const routes = [];
+    for (const filePath of routeFiles) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      const basePath = inferBasePath(apiRoutesRoot, filePath);
+      const routeCalls = findCallArguments(text, /fastify\.(get|post|put|patch|delete)\s*\(/g);
+      for (const routeCall of routeCalls) {
+        const [pathArg, optionsArg = "", handlerArg = ""] = routeCall.args;
+        if (!pathArg) continue;
+        const localPath = pathArg.trim().replace(/^["'`]|["'`]$/g, "") || "/";
+        const fullPath = joinRoutePath(basePath, localPath);
+        const schemaBlock = parseSchemaBlock(optionsArg);
+        const tags = schemaBlock ? parseTags(schemaBlock) : [];
+        const queryExpression = schemaBlock ? parseSchemaEntryExpression(schemaBlock, "querystring") : null;
+        const bodyExpression = schemaBlock ? parseSchemaEntryExpression(schemaBlock, "body") : null;
+        const paramsExpression = schemaBlock ? parseSchemaEntryExpression(schemaBlock, "params") : null;
+        const responseExpression = schemaBlock ? parseResponseExpression(schemaBlock) : null;
+        const operation = {
+          method: routeCall.method,
+          path: fullPath,
+          tags
+        };
+        routes.push({
+          file: filePath,
+          method: routeCall.method,
+          path: fullPath,
+          id_hint: inferApiCapabilityIdFromOperation(operation),
+          label: titleCase(inferApiCapabilityIdFromOperation(operation).replace(/^cap_/, "")),
+          path_params: parseSchemaExpressionFields(paramsExpression, namedSchemas).map((name) => ({ name, required: true, type: null })),
+          query_params: parseSchemaExpressionFields(queryExpression, namedSchemas).map((name) => ({ name, required: false, type: null })),
+          input_fields: parseSchemaExpressionFields(bodyExpression, namedSchemas),
+          output_fields: parseSchemaExpressionFields(responseExpression, namedSchemas),
+          auth_hint: inferFastifyAuthHint(fullPath, optionsArg),
+          entity_id: inferApiEntityIdFromPath(fullPath, { tags }),
+          tags,
+          provenance: `${relativeTo(context.paths.repoRoot, filePath)}#${routeCall.method} ${fullPath}`
+        });
+      }
+    }
+
+    const findings = [];
+    const candidates = { capabilities: [], routes: [], stacks: [] };
+    if (routes.length > 0) {
+      findings.push({
+        kind: "fastify_routes",
+        files: [...new Set(routes.map((route) => relativeTo(context.paths.repoRoot, route.file)))],
+        route_count: routes.length
+      });
+      candidates.capabilities.push(...routes.map((route) => makeCandidateRecord({
+        kind: "capability",
+        idHint: route.id_hint,
+        label: route.label,
+        confidence: "high",
+        sourceKind: "route_code",
+        provenance: route.provenance,
+        endpoint: { method: route.method, path: route.path },
+        path_params: route.path_params,
+        query_params: route.query_params,
+        header_params: [],
+        input_fields: route.input_fields,
+        output_fields: route.output_fields,
+        auth_hint: route.auth_hint,
+        entity_id: route.entity_id,
+        tags: route.tags,
+        track: "api"
+      })));
+      candidates.routes.push(...routes.map((route) => ({
+        path: route.path,
+        method: route.method,
+        confidence: "high",
+        source_kind: "route_code",
+        provenance: route.provenance
+      })));
+      candidates.stacks.push("fastify");
+    }
+
+    candidates.capabilities = dedupeCandidateRecords(candidates.capabilities, (record) => record.id_hint);
+    candidates.routes = dedupeCandidateRecords(
+      candidates.routes.map((route) => ({ ...route, id_hint: `${route.method}_${route.path}` })),
+      (record) => `${record.method}:${record.path}:${record.source_kind}`
+    ).map(({ id_hint, ...route }) => route);
+    candidates.stacks = [...new Set(candidates.stacks)].sort();
+
+    return { findings, candidates };
+  }
+};

package/src/import/extractors/api/flutter-dio.js

@@ -0,0 +1,135 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function featureStemFromPath(filePath) {
+  return canonicalCandidateTerm(filePath.match(/\/features\/([^/]+)\//)?.[1] || "item");
+}
+
+function pluralizeStem(stem) {
+  if (stem.endsWith("s")) return stem;
+  return `${stem}s`;
+}
+
+function capabilityIdFor(featureStem, methodName, httpMethod) {
+  const stem = canonicalCandidateTerm(featureStem);
+  const normalizedMethod = String(methodName || "").toLowerCase();
+  if (httpMethod === "GET") {
+    return `cap_list_${pluralizeStem(stem)}`;
+  }
+  if (httpMethod === "POST") {
+    return `cap_create_${stem}`;
+  }
+  if (httpMethod === "PUT" || httpMethod === "PATCH") {
+    return `cap_update_${stem}`;
+  }
+  if (httpMethod === "DELETE") {
+    return `cap_delete_${stem}`;
+  }
+  return `cap_${normalizedMethod}_${stem}`;
+}
+
+function extractApiConfigPaths(context) {
+  const configFile = findImportFiles(context.paths, (filePath) => /\/lib\/common\/network\/api_config\.dart$/i.test(filePath))[0];
+  const mapping = new Map();
+  if (!configFile) return mapping;
+  const text = context.helpers.readTextIfExists(configFile) || "";
+  for (const match of text.matchAll(/static\s+const\s+String\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*'([^']+)'/g)) {
+    mapping.set(match[1], match[2]);
+  }
+  return mapping;
+}
+
+function parseDatasourceFile(text, provenance, filePath, apiConfigPaths) {
+  const featureStem = featureStemFromPath(filePath);
+  const capabilities = [];
+  const methods = [...String(text || "").matchAll(/Future<[\s\S]*?>\s+([A-Za-z_][A-Za-z0-9_]*)\([^)]*\)\s+async\s*\{/g)];
+  for (let index = 0; index < methods.length; index += 1) {
+    const methodName = methods[index][1];
+    const bodyStart = methods[index].index + methods[index][0].length;
+    const bodyEnd = index + 1 < methods.length ? methods[index + 1].index : String(text || "").length;
+    const body = String(text || "").slice(bodyStart, bodyEnd);
+    const dioCall = body.match(/dioClient\.dio\.(get|post|put|patch|delete)\(([\s\S]*?)\)/i);
+    if (!dioCall) continue;
+    const httpMethod = dioCall[1].toUpperCase();
+    const callArgs = dioCall[2];
+    const apiRef = callArgs.match(/ApiConfig\.([A-Za-z_][A-Za-z0-9_]*)/);
+    const basePath = apiConfigPaths.get(apiRef?.[1] || "") || `/${pluralizeStem(featureStem)}`;
+    const dynamicPath = callArgs.match(/"\$\{ApiConfig\.[A-Za-z_][A-Za-z0-9_]*\}\/\$\{[^}]+\}"/);
+    const path = dynamicPath ? `${basePath}/{id}` : basePath;
+    const queryParams = [...body.matchAll(/'([^']+)'\s*:\s*[^,}]+/g)]
+      .map((entry) => ({ name: entry[1], required: false, type: null }));
+    const outputFields = /^GET$/.test(httpMethod) ? [pluralizeStem(featureStem)] : [];
+    const inputFields = [...new Set([...callArgs.matchAll(/data:\s*([A-Za-z_][A-Za-z0-9_]*)/g)].map((entry) => entry[1]))];
+    capabilities.push(makeCandidateRecord({
+      kind: "capability",
+      idHint: capabilityIdFor(featureStem, methodName, httpMethod),
+      label: titleCase(capabilityIdFor(featureStem, methodName, httpMethod).replace(/^cap_/, "")),
+      confidence: "high",
+      sourceKind: "route_code",
+      provenance: `${provenance}#${methodName}`,
+      endpoint: { method: httpMethod, path },
+      path_params: /\{id\}/.test(path) ? [{ name: "id", required: true, type: null }] : [],
+      query_params: queryParams,
+      header_params: [],
+      input_fields: inputFields,
+      output_fields: outputFields,
+      auth_hint: "public",
+      entity_id: `entity_${featureStem}`,
+      track: "api"
+    }));
+  }
+  return capabilities;
+}
+
+export const flutterDioExtractor = {
+  id: "api.flutter-dio",
+  track: "api",
+  detect(context) {
+    const files = findImportFiles(
+      context.paths,
+      (filePath) => /\/lib\/features\/.+\/data\/datasources\/.+_remote_data_source\.dart$/i.test(filePath)
+    );
+    const score = files.some((filePath) => /dioClient\.dio\./.test(context.helpers.readTextIfExists(filePath) || "")) ? 85 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found Flutter remote data sources using Dio"] : []
+    };
+  },
+  extract(context) {
+    const files = findImportFiles(
+      context.paths,
+      (filePath) => /\/lib\/features\/.+\/data\/datasources\/.+_remote_data_source\.dart$/i.test(filePath)
+    );
+    const apiConfigPaths = extractApiConfigPaths(context);
+    const capabilities = [];
+    for (const filePath of files) {
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      capabilities.push(...parseDatasourceFile(context.helpers.readTextIfExists(filePath) || "", provenance, filePath, apiConfigPaths));
+    }
+    const findings = capabilities.length > 0 ? [{
+      kind: "flutter_dio",
+      files: [...new Set(capabilities.flatMap((entry) => entry.provenance || []).map((entry) => String(entry).split("#")[0]))],
+      capability_count: capabilities.length
+    }] : [];
+    return {
+      findings,
+      candidates: {
+        capabilities: dedupeCandidateRecords(capabilities, (record) => `${record.id_hint}:${record.endpoint?.method}:${record.endpoint?.path}`),
+        routes: capabilities.map((entry) => ({
+          path: entry.endpoint.path,
+          method: entry.endpoint.method,
+          confidence: entry.confidence,
+          source_kind: entry.source_kind,
+          provenance: entry.provenance?.[0] || null
+        })),
+        stacks: capabilities.length > 0 ? ["flutter_dio"] : []
+      }
+    };
+  }
+};