@icyouo/evt-cli 0.1.0 → 0.1.1

package/scripts/sync-api-coverage.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { parseYaml } = require("../src/config/yaml");
+const { loadScanConfig, parseCliScanOptions, scanServices } = require("../src/config/serviceScanner");
+const { resolveCliPath, resolveConfigDir, setConfigRoot } = require("../src/util/paths");
+
+const endpointKey = (endpoint) => `${String(endpoint.method || "GET").toUpperCase()}:${endpoint.path}`;
+
+function readApiDocument(namespace) {
+  const apiDir = resolveApiOutputDir();
+  const file = path.join(apiDir, `${namespace}.yaml`);
+  if (!fs.existsSync(file)) {
+    return { namespace, endpoints: {} };
+  }
+  return parseYaml(fs.readFileSync(file, "utf8"));
+}
+
+function resolveApiOutputDir(scanOptions = {}) {
+  const scanConfig = loadScanConfig(scanOptions);
+  if (scanConfig.apiDir) return scanConfig.apiDir;
+  const legacyApiDir = resolveCliPath("apis");
+  const dataApiDir = resolveCliPath("data", "apis");
+  if (fs.existsSync(legacyApiDir)) return legacyApiDir;
+  if (fs.existsSync(dataApiDir)) return dataApiDir;
+  const resolved = resolveConfigDir("apis");
+  return fs.existsSync(resolved) ? resolved : dataApiDir;
+}
+
+function isPublicEndpoint(endpoint) {
+  const name = endpoint.functionName || endpoint.name || "";
+  const pathValue = endpoint.path || "";
+  return /^(login|register|oauth|public|health|status|version|languages?|config|list|get|search|check)/i.test(name) ||
+    /\/(public|health|status|version|config)\b/i.test(pathValue);
+}
+
+function isDangerousEndpoint(endpoint) {
+  const method = String(endpoint.method || "GET").toUpperCase();
+  if (method === "GET") return false;
+
+  const name = endpoint.functionName || endpoint.name || "";
+  const pathValue = endpoint.path || "";
+  if (/^(get|list|history|summary|check|send|login|verify|oauth)/i.test(name) && method === "POST") {
+    return false;
+  }
+  return /create|change|adjust|cancel|close|open|transfer|withdraw|bind|unbind|modify|patch|add|update|delete|disable|deactivate|identity|kyc|set|unlink|margin|leverage|order|password/i
+    .test(`${name} ${pathValue}`);
+}
+
+function makeEndpoint(scanned) {
+  const endpoint = {
+    method: scanned.method,
+    path: scanned.path,
+    auth: scanned.auth !== undefined ? scanned.auth : !isPublicEndpoint(scanned),
+    schema: {},
+    response: defaultResponse()
+  };
+
+  if (scanned.service) {
+    endpoint.service = scanned.service;
+  }
+  if (scanned.bodyType && scanned.bodyType !== "json") {
+    endpoint.bodyType = scanned.bodyType;
+  }
+  const dangerous = scanned.dangerous !== undefined ? scanned.dangerous : isDangerousEndpoint(scanned);
+  if (dangerous) {
+    endpoint.dangerous = true;
+  }
+  return endpoint;
+}
+
+function augmentEndpoint(namespace, name, endpoint) {
+  const inferred = { namespace, name, functionName: name, ...endpoint };
+  if (endpoint.dangerous === undefined && isDangerousEndpoint(inferred)) {
+    endpoint.dangerous = true;
+  }
+  endpoint.schema ||= {};
+  if (!endpoint.response || Object.keys(endpoint.response).length === 0) {
+    endpoint.response = defaultResponse();
+  }
+  return endpoint;
+}
+
+function defaultResponse() {
+  return {
+    data: {
+      type: "object"
+    }
+  };
+}
+
+function uniqueName(endpoints, preferred) {
+  if (!Object.prototype.hasOwnProperty.call(endpoints, preferred)) return preferred;
+  let suffix = 2;
+  while (Object.prototype.hasOwnProperty.call(endpoints, `${preferred}${suffix}`)) {
+    suffix += 1;
+  }
+  return `${preferred}${suffix}`;
+}
+
+function sortObjectByKeys(object) {
+  return Object.fromEntries(Object.entries(object).sort(([left], [right]) => left.localeCompare(right)));
+}
+
+function orderedEntries(object) {
+  const keyOrder = [
+    "service",
+    "method",
+    "path",
+    "auth",
+    "dangerous",
+    "bodyType",
+    "headers",
+    "query",
+    "body",
+    "schema",
+    "response"
+  ];
+  return Object.entries(object).sort(([left], [right]) => {
+    const leftIndex = keyOrder.indexOf(left);
+    const rightIndex = keyOrder.indexOf(right);
+    if (leftIndex !== -1 || rightIndex !== -1) {
+      return (leftIndex === -1 ? 999 : leftIndex) - (rightIndex === -1 ? 999 : rightIndex);
+    }
+    return left.localeCompare(right);
+  });
+}
+
+function yamlScalar(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value === null) return "null";
+  return JSON.stringify(value);
+}
+
+function writeYamlValue(lines, key, value, indent) {
+  const prefix = " ".repeat(indent);
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      lines.push(`${prefix}${key}: []`);
+      return;
+    }
+    lines.push(`${prefix}${key}:`);
+    for (const item of value) {
+      lines.push(`${prefix}  - ${yamlScalar(item)}`);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    const entries = orderedEntries(value);
+    if (entries.length === 0) {
+      lines.push(`${prefix}${key}: {}`);
+      return;
+    }
+    lines.push(`${prefix}${key}:`);
+    for (const [childKey, childValue] of entries) {
+      writeYamlValue(lines, childKey, childValue, indent + 2);
+    }
+    return;
+  }
+  lines.push(`${prefix}${key}: ${yamlScalar(value)}`);
+}
+
+function serializeDocument(document) {
+  const lines = [`namespace: ${document.namespace}`, "", "endpoints:"];
+  for (const [name, endpoint] of Object.entries(sortObjectByKeys(document.endpoints))) {
+    lines.push(`  ${name}:`);
+    for (const [key, value] of orderedEntries(endpoint)) {
+      writeYamlValue(lines, key, value, 4);
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n").replace(/\n+$/, "")}\n`;
+}
+
+function runSyncApiCoverage(argv = process.argv.slice(2)) {
+  const scanOptions = parseCliScanOptions(argv);
+  setConfigRoot(scanOptions.configRoot);
+  const apiDir = resolveApiOutputDir(scanOptions);
+  fs.mkdirSync(apiDir, { recursive: true });
+  const scanned = scanServices(scanOptions);
+  const existingNamespaces = fs.existsSync(apiDir)
+    ? fs.readdirSync(apiDir)
+      .filter((file) => file.endsWith(".yaml") || file.endsWith(".yml"))
+      .map((file) => path.basename(file, path.extname(file)))
+    : [];
+  const namespaces = [...new Set([...existingNamespaces, ...scanned.map((endpoint) => endpoint.namespace)])];
+  const documents = new Map(namespaces.map((namespace) => [namespace, readApiDocument(namespace)]));
+  const coveredPaths = new Set();
+
+  for (const document of documents.values()) {
+    document.endpoints ||= {};
+    for (const [name, endpoint] of Object.entries(document.endpoints)) {
+      document.endpoints[name] = augmentEndpoint(document.namespace, name, endpoint);
+      coveredPaths.add(endpointKey(endpoint));
+    }
+  }
+
+  let added = 0;
+  for (const endpoint of scanned) {
+    if (coveredPaths.has(endpointKey(endpoint))) continue;
+    const document = documents.get(endpoint.namespace);
+    const name = uniqueName(document.endpoints, endpoint.functionName);
+    document.endpoints[name] = makeEndpoint(endpoint);
+    coveredPaths.add(endpointKey(endpoint));
+    added += 1;
+  }
+
+  for (const namespace of namespaces) {
+    const document = documents.get(namespace);
+    if (!document.endpoints || Object.keys(document.endpoints).length === 0) continue;
+    fs.writeFileSync(path.join(apiDir, `${namespace}.yaml`), serializeDocument(document));
+  }
+
+  const payload = { scanned: scanned.length, added, namespaces: namespaces.length };
+  console.log(JSON.stringify(payload, null, 2));
+  return payload;
+}
+
+if (require.main === module) {
+  runSyncApiCoverage();
+}
+
+module.exports = {
+  runSyncApiCoverage
+};

package/skills/evt-api-scanner/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: evt-api-scanner
+description: Use when an agent needs to discover API source locations, generate evt-cli scanner config, scan a codebase for HTTP endpoints, sync YAML API definitions, or check endpoint coverage for evt-cli projects.
+---
+
+# evt-api-scanner
+
+Use this skill when working with an evt-cli project and you need to discover,
+scan, sync, or audit YAML API definitions.
+
+## Workflow
+
+1. Locate the project root and evt config root.
+   - Prefer the user's explicit `--config-root`.
+   - Otherwise use `EVT_CLI_ROOT`.
+   - Otherwise use `./cli` from the project root.
+2. Discover source locations and write scanner config:
+
+```bash
+node skills/evt-api-scanner/scripts/discover.js --root . --config-root ./cli
+```
+
+3. Generate or update endpoint YAML:
+
+```bash
+evt api sync --config-root ./cli
+```
+
+4. Check YAML coverage:
+
+```bash
+evt api coverage --config-root ./cli
+```
+
+## Endpoint Format
+
+Endpoint definitions are always persisted as YAML under `data/apis/*.yaml` or
+legacy `apis/*.yaml`. JSON is only used as a machine-readable intermediate
+between scanner scripts and evt-cli.
+
+Example YAML:
+
+```yaml
+namespace: auth
+
+endpoints:
+  login:
+    method: "POST"
+    path: "/api/login"
+    auth: false
+    schema: {}
+    response: {}
+```
+
+## Fallback
+
+evt-cli should prefer this skill scanner when configured. If the skill scanner
+fails or returns no endpoints, evt-cli falls back to the built-in regex scanner
+targets. The fallback exists for users without an agent or skill-aware workflow,
+but it is less complete.

package/skills/evt-api-scanner/scripts/discover.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const IGNORE_DIRS = new Set([
+  ".git",
+  ".gradle",
+  ".idea",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".ufoo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "Pods",
+  "target"
+]);
+
+const LANGUAGE_DEFS = {
+  kotlin: {
+    extensions: [".kt"],
+    hints: [/Service\.kt$/i, /Api\.kt$/i, /Repository\.kt$/i, /http\.(get|post|put|patch|delete)/]
+  },
+  swift: {
+    extensions: [".swift"],
+    hints: [/Service\.swift$/i, /API\.swift$/i, /Api\.swift$/i, /client\.(get|post|put|patch|delete)/]
+  },
+  js: {
+    extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"],
+    hints: [/(service|api|client|request|http)\.[cm]?[jt]sx?$/i, /\b(fetch|axios)\s*\(/, /\.(get|post|put|patch|delete)\s*\(/]
+  },
+  dart: {
+    extensions: [".dart"],
+    hints: [/(service|api|client|repository)\.dart$/i, /\.(get|post|put|patch|delete)\s*\(/]
+  }
+};
+
+function parseArgs(argv) {
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) continue;
+    const raw = token.slice(2);
+    const equals = raw.indexOf("=");
+    const key = (equals >= 0 ? raw.slice(0, equals) : raw)
+      .replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    if (key === "dryRun" || key === "json") {
+      options[key] = true;
+    } else {
+      options[key] = equals >= 0 ? raw.slice(equals + 1) : argv[++index];
+    }
+  }
+  return options;
+}
+
+function posixRelative(from, to) {
+  return path.relative(from, to).split(path.sep).join("/") || ".";
+}
+
+function defaultConfigRoot(cwd) {
+  if (process.env.EVT_CLI_ROOT) return path.resolve(process.env.EVT_CLI_ROOT);
+  if (process.env.EVERYTHING_CLI_ROOT) return path.resolve(process.env.EVERYTHING_CLI_ROOT);
+  if (path.basename(cwd) === "cli") return cwd;
+  return path.join(cwd, "cli");
+}
+
+function walkFiles(root, files = []) {
+  if (!fs.existsSync(root)) return files;
+  const stat = fs.statSync(root);
+  if (stat.isFile()) {
+    files.push(root);
+    return files;
+  }
+  if (!stat.isDirectory()) return files;
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (entry.isDirectory() && IGNORE_DIRS.has(entry.name)) continue;
+    walkFiles(path.join(root, entry.name), files);
+  }
+  return files;
+}
+
+function fileLooksRelevant(file, language, root) {
+  const def = LANGUAGE_DEFS[language];
+  const relative = posixRelative(root, file);
+  const basename = path.basename(file);
+  const text = fs.readFileSync(file, "utf8").slice(0, 20000);
+  return def.hints.some((hint) => hint.test(basename) || hint.test(relative) || hint.test(text));
+}
+
+function collapseDirs(root, files) {
+  const dirs = [...new Set(files.map((file) => path.dirname(file)))]
+    .map((dir) => posixRelative(root, dir))
+    .sort((left, right) => left.length - right.length || left.localeCompare(right));
+  const collapsed = [];
+  for (const dir of dirs) {
+    if (!collapsed.some((parent) => dir === parent || dir.startsWith(`${parent}/`))) {
+      collapsed.push(dir);
+    }
+  }
+  return collapsed;
+}
+
+function discoverTargets(projectRoot) {
+  const files = walkFiles(projectRoot);
+  const targets = [];
+  for (const [language, def] of Object.entries(LANGUAGE_DEFS)) {
+    const matching = files
+      .filter((file) => def.extensions.includes(path.extname(file)))
+      .filter((file) => fileLooksRelevant(file, language, projectRoot));
+    if (matching.length === 0) continue;
+    targets.push({ language, paths: collapseDirs(projectRoot, matching) });
+  }
+  return targets;
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const cwd = process.cwd();
+  const configRoot = path.resolve(options.configRoot || defaultConfigRoot(cwd));
+  const projectRoot = path.resolve(options.root || (path.basename(configRoot) === "cli" ? path.dirname(configRoot) : cwd));
+  const dataDir = path.join(configRoot, "data");
+  const apiDir = path.join(dataDir, "apis");
+  const scannerFile = path.resolve(options.scannerFile || path.join(dataDir, "scanner.json"));
+  const scannerDir = path.dirname(scannerFile);
+  const fallbackTargets = discoverTargets(projectRoot);
+  const config = {
+    root: posixRelative(scannerDir, projectRoot),
+    apiDir: posixRelative(scannerDir, apiDir),
+    targets: [
+      {
+        language: "skill",
+        name: "evt-api-scanner",
+        skill: "evt-api-scanner"
+      },
+      ...fallbackTargets
+    ]
+  };
+
+  if (!options.dryRun) {
+    fs.mkdirSync(apiDir, { recursive: true });
+    fs.mkdirSync(path.join(dataDir, "flows"), { recursive: true });
+    fs.mkdirSync(path.join(dataDir, "profiles"), { recursive: true });
+    fs.mkdirSync(scannerDir, { recursive: true });
+    fs.writeFileSync(scannerFile, `${JSON.stringify(config, null, 2)}\n`);
+  }
+
+  process.stdout.write(`${JSON.stringify({
+    wrote: !options.dryRun,
+    projectRoot,
+    configRoot,
+    scannerFile,
+    apiDir,
+    targets: config.targets
+  }, null, 2)}\n`);
+}
+
+main();

package/skills/evt-api-scanner/scripts/scan.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const IGNORE_DIRS = new Set([
+  ".git",
+  ".gradle",
+  ".idea",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".ufoo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "Pods",
+  "target"
+]);
+
+const LANGUAGE_DEFS = {
+  kotlin: {
+    extensions: [".kt"],
+    receivers: ["http", "client", "api"],
+    helpers: ["get", "getRaw", "post", "postUrlEncoded", "postForm", "put", "patch", "delete", "deleteWithBody", "upload"],
+    functions: [/(?:override\s+)?suspend\s+fun\s+([A-Za-z_][A-Za-z0-9_]*)/g, /fun\s+([A-Za-z_][A-Za-z0-9_]*)/g],
+    stripPrefixes: ["I"],
+    stripSuffixes: ["Service", "Api", "API", "Repository"]
+  },
+  swift: {
+    extensions: [".swift"],
+    receivers: ["http", "client", "api"],
+    helpers: ["get", "post", "put", "patch", "delete", "upload"],
+    functions: [/func\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/g],
+    stripSuffixes: ["Service", "Api", "API"]
+  },
+  js: {
+    extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"],
+    receivers: ["http", "client", "api", "axios"],
+    helpers: ["get", "post", "put", "patch", "delete"],
+    functions: [
+      /(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g,
+      /(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?\(/g,
+      /([A-Za-z_$][A-Za-z0-9_$]*)\s*:\s*(?:async\s*)?function\s*\(/g
+    ],
+    stripSuffixes: ["Service", "Api", "API"]
+  },
+  dart: {
+    extensions: [".dart"],
+    receivers: ["http", "client", "api", "dio"],
+    helpers: ["get", "post", "put", "patch", "delete"],
+    functions: [
+      /(?:Future(?:<[^>]+>)?|Stream(?:<[^>]+>)?|void|[A-Za-z_][A-Za-z0-9_<>?]*)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\([^)]*\)\s*(?:async\s*)?\{/g
+    ],
+    stripSuffixes: ["Service", "Api", "API"]
+  }
+};
+
+const METHOD_BY_HELPER = {
+  get: "GET",
+  getRaw: "GET",
+  fetch: "GET",
+  post: "POST",
+  postForm: "POST",
+  postUrlEncoded: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE",
+  deleteWithBody: "DELETE",
+  upload: "POST"
+};
+
+const STRING_PATTERN = `"([^"]+)"|'([^']+)'|\`([^\`]+)\``;
+
+function parseArgs(argv) {
+  const options = { paths: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) {
+      options.paths.push(token);
+      continue;
+    }
+    const raw = token.slice(2);
+    const equals = raw.indexOf("=");
+    const key = (equals >= 0 ? raw.slice(0, equals) : raw)
+      .replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    options[key] = equals >= 0 ? raw.slice(equals + 1) : argv[++index];
+  }
+  return options;
+}
+
+function posixRelative(from, to) {
+  return path.relative(from, to).split(path.sep).join("/") || ".";
+}
+
+function walkFiles(root, files = []) {
+  if (!fs.existsSync(root)) return files;
+  const stat = fs.statSync(root);
+  if (stat.isFile()) {
+    files.push(root);
+    return files;
+  }
+  if (!stat.isDirectory()) return files;
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (entry.isDirectory() && IGNORE_DIRS.has(entry.name)) continue;
+    walkFiles(path.join(root, entry.name), files);
+  }
+  return files;
+}
+
+function languageForFile(file) {
+  const extension = path.extname(file);
+  return Object.entries(LANGUAGE_DEFS).find(([, def]) => def.extensions.includes(extension))?.[0];
+}
+
+function makeRegexUnion(values) {
+  return values.map((value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+}
+
+function firstQuoted(match, startIndex) {
+  for (let index = startIndex; index < match.length; index += 1) {
+    if (match[index] !== undefined) return match[index];
+  }
+  return undefined;
+}
+
+function nearestFunction(source, index, def) {
+  const before = source.slice(0, index);
+  let nearest = { index: -1, name: "unknown" };
+  for (const pattern of def.functions) {
+    pattern.lastIndex = 0;
+    for (const match of before.matchAll(pattern)) {
+      if (match.index > nearest.index) nearest = { index: match.index, name: match[1] };
+    }
+  }
+  return nearest.name;
+}
+
+function namespaceForFile(file, language) {
+  const def = LANGUAGE_DEFS[language];
+  let namespace = path.basename(file, path.extname(file));
+  for (const prefix of def.stripPrefixes || []) {
+    if (namespace.startsWith(prefix)) namespace = namespace.slice(prefix.length);
+  }
+  for (const suffix of def.stripSuffixes || []) {
+    if (namespace.endsWith(suffix)) namespace = namespace.slice(0, -suffix.length);
+  }
+  return namespace.replace(/^[A-Z]/, (letter) => letter.toLowerCase());
+}
+
+function normalizePath(rawPath, language) {
+  if (!rawPath || !rawPath.startsWith("/")) return undefined;
+  let value = rawPath
+    .replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, ":$1")
+    .replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, ":$1");
+  if (language === "swift") value = value.replace(/\\\(([A-Za-z_][A-Za-z0-9_]*)\)/g, ":$1");
+  return value;
+}
+
+function bodyTypeFor(helper) {
+  if (helper === "postUrlEncoded") return "formUrlEncoded";
+  if (helper === "postForm" || helper === "upload") return "multipart";
+  return "json";
+}
+
+function pushEndpoint(endpoints, seen, file, root, source, language, helper, rawPath, matchIndex, explicitMethod) {
+  const pathTemplate = normalizePath(rawPath, language);
+  if (!pathTemplate) return;
+  const namespace = namespaceForFile(file, language);
+  const functionName = nearestFunction(source, matchIndex, LANGUAGE_DEFS[language]);
+  const method = String(explicitMethod || METHOD_BY_HELPER[helper] || helper).toUpperCase();
+  const key = `${method}:${pathTemplate}:${functionName}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  endpoints.push({
+    id: `${namespace}.${functionName}`,
+    namespace,
+    functionName,
+    method,
+    path: pathTemplate,
+    bodyType: bodyTypeFor(helper),
+    helper,
+    file: posixRelative(root, file),
+    source: "evt-api-scanner"
+  });
+}
+
+function scanFile(file, root) {
+  const language = languageForFile(file);
+  if (!language) return [];
+  const def = LANGUAGE_DEFS[language];
+  const source = fs.readFileSync(file, "utf8");
+  const endpoints = [];
+  const seen = new Set();
+  const receiverPattern = makeRegexUnion(def.receivers);
+  const helperPattern = makeRegexUnion(def.helpers);
+  const calls = [
+    new RegExp(`\\b(?:${receiverPattern})\\s*\\.\\s*(${helperPattern})(?:<[^>]+>)?\\s*\\(\\s*(?:${STRING_PATTERN})`, "g"),
+    new RegExp(`\\b(?:${receiverPattern})\\s*\\.\\s*(${helperPattern})(?:<[^>]+>)?\\s*\\([\\s\\S]{0,300}?\\burl\\s*=\\s*(?:${STRING_PATTERN})`, "g"),
+    new RegExp(`\\b(?:${receiverPattern})\\s*\\.\\s*(${helperPattern})\\s*\\(\\s*Uri\\.parse\\s*\\(\\s*(?:${STRING_PATTERN})`, "g")
+  ];
+  for (const pattern of calls) {
+    let match;
+    while ((match = pattern.exec(source)) !== null) {
+      pushEndpoint(endpoints, seen, file, root, source, language, match[1], firstQuoted(match, 2), match.index);
+    }
+  }
+
+  if (language === "js") {
+    const fetchCall = new RegExp(`\\bfetch\\s*\\(\\s*(?:${STRING_PATTERN})([\\s\\S]{0,300}?)\\)`, "g");
+    let match;
+    while ((match = fetchCall.exec(source)) !== null) {
+      const optionsSource = match[4] || "";
+      const methodMatch = optionsSource.match(/\bmethod\s*:\s*["'`]([A-Za-z]+)["'`]/);
+      pushEndpoint(endpoints, seen, file, root, source, language, "fetch", firstQuoted(match, 1), match.index, methodMatch && methodMatch[1]);
+    }
+  }
+  return endpoints;
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const root = path.resolve(options.root || process.env.EVT_SCAN_ROOT || process.cwd());
+  const entries = options.paths.length > 0 ? options.paths.map((entry) => path.resolve(root, entry)) : [root];
+  const files = entries.flatMap((entry) => walkFiles(entry)).filter(languageForFile);
+  const endpoints = files.flatMap((file) => scanFile(file, root));
+  process.stdout.write(`${JSON.stringify({ endpoints }, null, 2)}\n`);
+}
+
+main();