@appilots/cli 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,4178 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+var import_commander7 = require("commander");
+
+// src/config/index.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_fs2 = require("fs");
+function getEnvOverrides(env = process.env) {
+  const clean = (value) => {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : void 0;
+  };
+  return {
+    apiKey: clean(env.APPILOTS_API_KEY),
+    projectId: clean(env.APPILOTS_PROJECT_ID),
+    serverUrl: clean(env.APPILOTS_SERVER_URL)
+  };
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  const env = getEnvOverrides();
+  let fileConfig = {};
+  if (configPath) {
+    try {
+      fileConfig = JSON.parse((0, import_fs.readFileSync)(configPath, "utf-8"));
+    } catch (error2) {
+      throw new Error(`Failed to parse .appilotsrc at ${configPath}: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+    }
+  } else if (!env.apiKey) {
+    return null;
+  }
+  const merged = {
+    serverUrl: "http://localhost:4000",
+    outputDir: ".appilots",
+    autoActivate: true,
+    strictScreens: true,
+    ...fileConfig,
+    ...env.apiKey ? { apiKey: env.apiKey } : {},
+    ...env.projectId ? { projectId: env.projectId } : {},
+    ...env.serverUrl ? { serverUrl: env.serverUrl } : {}
+  };
+  const validation = validateConfig(merged);
+  if (!validation.valid) {
+    const source = configPath ?? "environment variables";
+    throw new Error(
+      `Invalid Appilots configuration (${source}):
+` + validation.errors.map((e) => `  - ${e}`).join("\n") + "\nFix .appilotsrc or set APPILOTS_API_KEY / APPILOTS_SERVER_URL."
+    );
+  }
+  return merged;
+}
+function saveConfig(dir, config) {
+  const configPath = (0, import_path.join)(dir, ".appilotsrc");
+  const existingConfig = getConfigPath() ? loadConfig() : null;
+  const mergedConfig = {
+    apiKey: config.apiKey || existingConfig?.apiKey || "",
+    projectId: config.projectId || existingConfig?.projectId || "",
+    serverUrl: config.serverUrl || existingConfig?.serverUrl || "http://localhost:4000",
+    outputDir: config.outputDir || existingConfig?.outputDir || ".appilots",
+    autoActivate: config.autoActivate !== void 0 ? config.autoActivate : existingConfig?.autoActivate ?? true,
+    include: config.include || existingConfig?.include,
+    exclude: config.exclude || existingConfig?.exclude,
+    strictScreens: config.strictScreens ?? existingConfig?.strictScreens ?? true,
+    screenPatterns: config.screenPatterns || existingConfig?.screenPatterns,
+    navigationInclude: config.navigationInclude || existingConfig?.navigationInclude,
+    navigationExclude: config.navigationExclude || existingConfig?.navigationExclude,
+    eval: config.eval || existingConfig?.eval
+  };
+  try {
+    (0, import_fs.writeFileSync)(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
+  } catch (error2) {
+    throw new Error(`Failed to write .appilotsrc to ${configPath}: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+  }
+}
+function getConfigPath() {
+  let currentDir = (0, import_path.resolve)(process.cwd());
+  const root = (0, import_path.resolve)("/");
+  while (currentDir !== root) {
+    const configPath = (0, import_path.join)(currentDir, ".appilotsrc");
+    try {
+      if ((0, import_fs2.existsSync)(configPath) && (0, import_fs2.statSync)(configPath).isFile()) {
+        return configPath;
+      }
+    } catch {
+    }
+    currentDir = (0, import_path.resolve)(currentDir, "..");
+  }
+  const rootConfigPath = (0, import_path.join)(root, ".appilotsrc");
+  try {
+    if ((0, import_fs2.existsSync)(rootConfigPath) && (0, import_fs2.statSync)(rootConfigPath).isFile()) {
+      return rootConfigPath;
+    }
+  } catch {
+  }
+  return null;
+}
+function validateConfig(config) {
+  const errors = [];
+  if (!config || typeof config !== "object") {
+    return {
+      valid: false,
+      errors: ["Configuration must be an object"]
+    };
+  }
+  if (!config.apiKey || typeof config.apiKey !== "string") {
+    errors.push("apiKey is required and must be a string (set it in .appilotsrc or via APPILOTS_API_KEY)");
+  } else if (!config.apiKey.startsWith("ak_")) {
+    errors.push('apiKey must start with "ak_"');
+  }
+  if (config.projectId !== void 0 && config.projectId !== "" && typeof config.projectId !== "string") {
+    errors.push("projectId must be a string");
+  }
+  if (config.serverUrl !== void 0 && typeof config.serverUrl !== "string") {
+    errors.push("serverUrl must be a string");
+  }
+  if (config.outputDir !== void 0 && typeof config.outputDir !== "string") {
+    errors.push("outputDir must be a string");
+  }
+  if (config.include !== void 0 && !Array.isArray(config.include)) {
+    errors.push("include must be an array of strings");
+  } else if (Array.isArray(config.include) && !config.include.every((item) => typeof item === "string")) {
+    errors.push("include must be an array of strings");
+  }
+  if (config.exclude !== void 0 && !Array.isArray(config.exclude)) {
+    errors.push("exclude must be an array of strings");
+  } else if (Array.isArray(config.exclude) && !config.exclude.every((item) => typeof item === "string")) {
+    errors.push("exclude must be an array of strings");
+  }
+  if (config.autoActivate !== void 0 && typeof config.autoActivate !== "boolean") {
+    errors.push("autoActivate must be a boolean");
+  }
+  if (config.strictScreens !== void 0 && typeof config.strictScreens !== "boolean") {
+    errors.push("strictScreens must be a boolean");
+  }
+  for (const field of ["screenPatterns", "navigationInclude", "navigationExclude"]) {
+    const value = config[field];
+    if (value !== void 0 && (!Array.isArray(value) || !value.every((item) => typeof item === "string"))) {
+      errors.push(`${field} must be an array of strings`);
+    }
+  }
+  if (config.eval !== void 0) {
+    if (typeof config.eval !== "object" || config.eval === null || Array.isArray(config.eval)) {
+      errors.push("eval must be an object");
+    } else {
+      const evalConfig = config.eval;
+      if (evalConfig.scenariosDir !== void 0 && typeof evalConfig.scenariosDir !== "string") {
+        errors.push("eval.scenariosDir must be a string");
+      }
+      if (evalConfig.baselinePath !== void 0 && typeof evalConfig.baselinePath !== "string") {
+        errors.push("eval.baselinePath must be a string");
+      }
+      if (evalConfig.minPassRate !== void 0 && (typeof evalConfig.minPassRate !== "number" || evalConfig.minPassRate < 0 || evalConfig.minPassRate > 1)) {
+        errors.push("eval.minPassRate must be a number between 0 and 1");
+      }
+      if (evalConfig.maxTokenRegression !== void 0 && (typeof evalConfig.maxTokenRegression !== "number" || evalConfig.maxTokenRegression < 0)) {
+        errors.push("eval.maxTokenRegression must be a non-negative number");
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/cli/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var mode = "pretty";
+function setLogMode(next) {
+  mode = next;
+}
+function jsonOutput(payload) {
+  if (mode === "json") {
+    console.log(JSON.stringify(payload, null, 2));
+  }
+}
+function createSpinner(text) {
+  return (0, import_ora.default)({ text, isSilent: mode !== "pretty" });
+}
+function success(msg) {
+  if (mode !== "pretty") return;
+  console.log(import_chalk.default.green.bold("\u2713"), msg);
+}
+function error(msg) {
+  if (mode === "json") {
+    console.error(import_chalk.default.red.bold("\u2717"), msg);
+    return;
+  }
+  console.log(import_chalk.default.red.bold("\u2717"), msg);
+}
+function warn(msg) {
+  if (mode === "json") {
+    console.error(import_chalk.default.yellow.bold("\u26A0"), msg);
+    return;
+  }
+  console.log(import_chalk.default.yellow.bold("\u26A0"), msg);
+}
+function info(msg) {
+  if (mode !== "pretty") return;
+  console.log(import_chalk.default.blue.bold("\u2139"), msg);
+}
+function dim(msg) {
+  if (mode !== "pretty") return;
+  console.log(import_chalk.default.dim(msg));
+}
+function banner() {
+  if (mode !== "pretty") return;
+  const logo = `
+  ${import_chalk.default.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
+  ${import_chalk.default.cyan("\u2551")}     ${import_chalk.default.bold.cyan("Appilots MCP Generator")}          ${import_chalk.default.cyan("\u2551")}
+  ${import_chalk.default.cyan("\u2551")}     ${import_chalk.default.dim("v0.1.0")}                    ${import_chalk.default.cyan("\u2551")}
+  ${import_chalk.default.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
+  `;
+  console.log(logo);
+}
+function heading(msg) {
+  if (mode !== "pretty") return;
+  console.log(msg);
+}
+function table(rows) {
+  if (mode !== "pretty" || rows.length === 0) {
+    return;
+  }
+  const maxKeyLength = Math.max(...rows.map(([key]) => key.length));
+  rows.forEach(([key, value]) => {
+    const padding = " ".repeat(maxKeyLength - key.length + 2);
+    console.log(`  ${import_chalk.default.bold(key)}${padding}${value}`);
+  });
+}
+
+// src/cli/commands/init.ts
+var import_commander = require("commander");
+
+// src/services/api-client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var RETRY_BASE_DELAY_MS = 500;
+var AppilotsAPIClient = class {
+  serverUrl;
+  apiKey;
+  timeoutMs;
+  maxRetries;
+  constructor(config) {
+    this.serverUrl = config.serverUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+  }
+  /**
+   * fetch with a hard timeout and exponential-backoff retries. Retries
+   * only on network failures and 5xx responses — 4xx are the caller's
+   * problem and retrying them would just spam the server.
+   */
+  async request(url, init) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        await new Promise((r) => setTimeout(r, RETRY_BASE_DELAY_MS * 2 ** (attempt - 1)));
+      }
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const response = await fetch(url, { ...init, signal: controller.signal });
+        if (response.status >= 500 && attempt < this.maxRetries) {
+          lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+          continue;
+        }
+        return response;
+      } catch (err) {
+        lastError = controller.signal.aborted ? new Error(`Request timed out after ${this.timeoutMs}ms: ${url}`) : err;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+  /**
+   * Syncs content with the Appilots backend
+   *
+   * @param content The MCP content object to sync
+   * @param version Version string for the content
+   * @param appVersion Host app version (package.json) — sent as
+   *                   X-App-Version so the backend can associate the MCP
+   *                   document with the app build that produced it
+   * @returns SyncResult with success status and metadata
+   */
+  async sync(content, version, appVersion) {
+    try {
+      const response = await this.request(`${this.serverUrl}/api/v1/cli/sync`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          ...appVersion ? { "X-App-Version": appVersion } : {}
+        },
+        body: JSON.stringify({ content, version })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        return {
+          success: false,
+          unchanged: false,
+          error: errorData?.error || `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const json = await response.json();
+      const inner = json.data ?? json;
+      return {
+        success: true,
+        ...inner
+      };
+    } catch (error2) {
+      return {
+        success: false,
+        unchanged: false,
+        error: error2 instanceof Error ? error2.message : "Failed to sync with Appilots API"
+      };
+    }
+  }
+  /**
+   * Gets the status of the Appilots project and active MCP
+   *
+   * @returns StatusResult with project and active MCP information
+   */
+  async status() {
+    try {
+      const response = await this.request(`${this.serverUrl}/api/v1/cli/status`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        }
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        return {
+          error: errorData?.error || `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const json = await response.json();
+      const inner = json.data ?? json;
+      return inner;
+    } catch (error2) {
+      return {
+        error: error2 instanceof Error ? error2.message : "Failed to fetch status from Appilots API"
+      };
+    }
+  }
+  /**
+   * Runs a batch of eval scenarios against the project's MCP document in
+   * decision/dry-run mode — no side effects, same relay path as the
+   * dashboard's sandbox, authenticated with this client's API key.
+   *
+   * @param scenarios Scenarios to run, capped server-side at
+   *   EVAL_MAX_SCENARIOS_PER_RUN (currently 20) as a cost guard.
+   */
+  async evalRun(scenarios) {
+    try {
+      const response = await this.request(`${this.serverUrl}/api/v1/cli/eval/run`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ scenarios })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const errObj = errorData?.error;
+        return {
+          error: errObj?.message || `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const json = await response.json();
+      const inner = json.data ?? json;
+      return { results: inner.results ?? [] };
+    } catch (error2) {
+      return {
+        error: error2 instanceof Error ? error2.message : "Failed to run eval against Appilots API"
+      };
+    }
+  }
+  /**
+   * Checks if the Appilots API server is healthy
+   *
+   * @returns true if server is healthy, false otherwise
+   */
+  async health() {
+    try {
+      const response = await this.request(`${this.serverUrl}/api/v1/health`, {
+        method: "GET"
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/cli/commands/init.ts
+var import_fs3 = require("fs");
+var import_path2 = require("path");
+function ensureConfigIgnored(dir) {
+  const gitignorePath = (0, import_path2.join)(dir, ".gitignore");
+  if (!(0, import_fs3.existsSync)(gitignorePath)) {
+    return "no-gitignore";
+  }
+  const lines = (0, import_fs3.readFileSync)(gitignorePath, "utf-8").split(/\r?\n/);
+  const ignored = lines.some((line) => {
+    const entry = line.trim();
+    return entry === ".appilotsrc" || entry === "/.appilotsrc" || entry === ".appilotsrc/";
+  });
+  if (ignored) {
+    return "already-ignored";
+  }
+  (0, import_fs3.appendFileSync)(gitignorePath, "\n# Appilots CLI config (contains your API key \u2014 do not commit)\n.appilotsrc\n");
+  return "added";
+}
+function initCommand() {
+  return new import_commander.Command("init").description("Set up Appilots configuration interactively").option("--api-key <key>", "Appilots API key (ak_... format)").option("--server <url>", "Appilots server URL").action(async (options) => {
+    try {
+      banner();
+      const configPath = getConfigPath();
+      if (configPath) {
+        warn(`Found existing .appilotsrc at ${configPath}`);
+        warn("Use --api-key and --server to override settings");
+      }
+      const env = getEnvOverrides();
+      const apiKey = options.apiKey || env.apiKey;
+      if (!apiKey) {
+        error("API key is required");
+        info("Provide it with: --api-key <your-ak_...key>");
+        info("Or set APPILOTS_API_KEY environment variable");
+        process.exit(1);
+      }
+      if (!options.apiKey && env.apiKey) {
+        info("Using API key from APPILOTS_API_KEY environment variable");
+      }
+      const serverUrl = options.server || env.serverUrl || "http://localhost:4000";
+      if (!apiKey.startsWith("ak_")) {
+        error("Invalid API key format. Must start with ak_");
+        process.exit(1);
+      }
+      info("Validating API key...");
+      const apiClient = new AppilotsAPIClient({
+        serverUrl,
+        apiKey
+      });
+      const isHealthy = await apiClient.health();
+      if (!isHealthy) {
+        error(`Cannot reach Appilots server at ${serverUrl}`);
+        info("Make sure the server is running and the URL is correct");
+        process.exit(1);
+      }
+      const status = await apiClient.status();
+      if (status.error) {
+        error(`Failed to validate API key: ${status.error}`);
+        process.exit(1);
+      }
+      if (!status.project) {
+        error("Could not retrieve project information");
+        process.exit(1);
+      }
+      success(`\u2713 Successfully connected to ${status.project.name}`);
+      success(`\u2713 Project ID: ${status.project.id}`);
+      const config = {
+        apiKey,
+        projectId: status.project.id,
+        serverUrl,
+        outputDir: ".appilots",
+        autoActivate: true
+      };
+      saveConfig(process.cwd(), config);
+      success("Configuration saved to .appilotsrc");
+      switch (ensureConfigIgnored(process.cwd())) {
+        case "added":
+          success("Added .appilotsrc to .gitignore (it contains your API key)");
+          break;
+        case "no-gitignore":
+          warn(".appilotsrc contains your API key \u2014 make sure it is NOT committed");
+          info('Add ".appilotsrc" to your .gitignore');
+          break;
+        case "already-ignored":
+          break;
+      }
+      info("Next steps:");
+      dim("  $ appilots sync  - Analyze and upload your project");
+      dim("  $ appilots watch - Watch for changes and auto-sync");
+    } catch (err) {
+      error(`Initialization failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/sync.ts
+var import_commander2 = require("commander");
+var import_promises3 = require("fs/promises");
+var import_node_path2 = require("path");
+
+// src/generators/MCPGenerator.ts
+var import_promises2 = require("fs/promises");
+var import_node_crypto = require("crypto");
+var import_node_path = __toESM(require("path"));
+
+// src/analyzers/ScreenAnalyzer.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_path3 = __toESM(require("path"));
+var import_traverse4 = __toESM(require("@babel/traverse"));
+var BabelTypes = __toESM(require("@babel/types"));
+var import_fast_glob = __toESM(require("fast-glob"));
+
+// src/ast/parse.ts
+var import_parser = require("@babel/parser");
+var DEFAULT_PARSER_PLUGINS = [
+  "jsx",
+  "typescript",
+  ["decorators", { decoratorsBeforeExport: true }],
+  "asyncGenerators",
+  ["pipelineOperator", { proposal: "minimal" }],
+  "partialApplication",
+  "logicalAssignment",
+  "classPrivateProperties",
+  "classPrivateMethods",
+  ["recordAndTuple", { syntaxType: "hash" }]
+];
+function parseSource(source, parserPlugins = []) {
+  return (0, import_parser.parse)(source, {
+    sourceType: "module",
+    plugins: [...DEFAULT_PARSER_PLUGINS, ...parserPlugins]
+  });
+}
+
+// src/ast/jsx/attributes.ts
+var t = __toESM(require("@babel/types"));
+function findJsxAttribute(element, name) {
+  return element.attributes.find(
+    (attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === name
+  );
+}
+function getStringAttr(element, name) {
+  const attr = findJsxAttribute(element, name);
+  if (!attr || !attr.value) return void 0;
+  if (t.isStringLiteral(attr.value)) return attr.value.value;
+  if (t.isJSXExpressionContainer(attr.value) && t.isStringLiteral(attr.value.expression)) {
+    return attr.value.expression.value;
+  }
+  return void 0;
+}
+function getExpressionIdentifierAttr(element, name) {
+  const attr = findJsxAttribute(element, name);
+  if (!attr?.value || !t.isJSXExpressionContainer(attr.value)) return void 0;
+  return t.isIdentifier(attr.value.expression) ? attr.value.expression.name : void 0;
+}
+function hasJsxAttribute(element, name) {
+  return Boolean(findJsxAttribute(element, name));
+}
+
+// src/ast/jsx/classify.ts
+var VIEW_COMPONENTS = /* @__PURE__ */ new Set(["View", "ScrollView", "SafeAreaView", "KeyboardAvoidingView"]);
+var INPUT_COMPONENTS = /* @__PURE__ */ new Set(["TextInput", "Input", "HocInput"]);
+var BUTTON_COMPONENTS = /* @__PURE__ */ new Set(["TouchableOpacity", "Pressable", "Button"]);
+var LIST_COMPONENTS = /* @__PURE__ */ new Set(["FlatList", "SectionList", "VirtualizedList", "FlashList"]);
+var MODAL_COMPONENTS = /* @__PURE__ */ new Set(["Modal", "BottomSheet"]);
+function classifyJsxComponent(name, element) {
+  if (LIST_COMPONENTS.has(name)) return "list";
+  if (MODAL_COMPONENTS.has(name)) return "modal";
+  if (/date/i.test(name)) return "date";
+  if (/(select|picker|dropdown|radio)/i.test(name)) return "select";
+  if (/(checkbox|switch|toggle)/i.test(name)) return "toggle";
+  if (INPUT_COMPONENTS.has(name)) return "input";
+  if (BUTTON_COMPONENTS.has(name)) return "button";
+  if (element) {
+    const hasOptions = hasJsxAttribute(element, "options");
+    const hasValue = hasJsxAttribute(element, "value");
+    const hasChecked = hasJsxAttribute(element, "checked") || hasJsxAttribute(element, "selected");
+    const hasOnChange = hasJsxAttribute(element, "onChange") || hasJsxAttribute(element, "onValueChange") || hasJsxAttribute(element, "onChangeText");
+    const hasOnPress = hasJsxAttribute(element, "onPress");
+    if (hasOptions && (hasValue || hasOnChange)) return "select";
+    if (hasChecked && hasOnChange) return "toggle";
+    if (hasOnChange && (hasJsxAttribute(element, "label") || hasJsxAttribute(element, "placeholder"))) {
+      return "input";
+    }
+    if (hasOnPress) return "button";
+    if (getStringAttr(element, "visible") || getExpressionIdentifierAttr(element, "visible")) {
+      return "modal";
+    }
+  }
+  if (VIEW_COMPONENTS.has(name)) return "view";
+  return "custom";
+}
+
+// src/ast/functions/collect.ts
+var import_traverse = __toESM(require("@babel/traverse"));
+var t2 = __toESM(require("@babel/types"));
+function collectFunctions(ast) {
+  const handlers = /* @__PURE__ */ new Map();
+  (0, import_traverse.default)(ast, {
+    FunctionDeclaration: (nodePath) => {
+      if (nodePath.node.id?.name) handlers.set(nodePath.node.id.name, nodePath.node);
+    },
+    VariableDeclarator: (nodePath) => {
+      if (!t2.isIdentifier(nodePath.node.id)) return;
+      const init = nodePath.node.init;
+      if (t2.isArrowFunctionExpression(init) || t2.isFunctionExpression(init)) {
+        handlers.set(nodePath.node.id.name, init);
+      }
+    }
+  });
+  return handlers;
+}
+
+// src/ast/functions/analyze-async.ts
+var import_traverse2 = __toESM(require("@babel/traverse"));
+var t3 = __toESM(require("@babel/types"));
+var DESTRUCTIVE_VERB = /(delete|destroy|remove|discard|wipe|erase|drop|terminate|revoke|deactivate|disable)/i;
+function analyzeFunctionBehavior(name, fn, handlers, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(name)) {
+    return {
+      appilotsInferred: { expectedOutcome: "none" },
+      destructive: false,
+      nativeConfirmationExpected: false
+    };
+  }
+  seen.add(name);
+  let hasAwait = fn.async === true;
+  let hasThen = false;
+  let hasStateSetter = false;
+  let nativeConfirmationExpected = false;
+  let targetScreen;
+  let successSignal;
+  let failureSignal;
+  let opensModal;
+  let destructive = DESTRUCTIVE_VERB.test(name);
+  const loadingStateBindings = /* @__PURE__ */ new Set();
+  const inspectCall = (node) => {
+    if (t3.isMemberExpression(node.callee) && t3.isIdentifier(node.callee.property)) {
+      const method = node.callee.property.name;
+      if (method === "then" || method === "catch" || method === "finally") hasThen = true;
+      if (t3.isIdentifier(node.callee.object) && node.callee.object.name === "navigation" && ["navigate", "push", "replace"].includes(method)) {
+        const firstArg = node.arguments[0];
+        if (t3.isStringLiteral(firstArg)) {
+          targetScreen = firstArg.value;
+          successSignal = { type: "navigation", target: firstArg.value };
+        }
+      }
+      if (t3.isIdentifier(node.callee.object) && node.callee.object.name === "navigation" && method === "goBack") {
+        successSignal = { type: "goBack", description: "Action returns to the previous screen" };
+      }
+      if (t3.isIdentifier(node.callee.object) && node.callee.object.name === "Alert" && method === "alert") {
+        nativeConfirmationExpected = true;
+      }
+      if (t3.isIdentifier(node.callee.object) && /(toast|notification|snackbar)/i.test(node.callee.object.name)) {
+        const firstArg = node.arguments[0];
+        const secondArg = node.arguments[1];
+        const text = t3.isStringLiteral(secondArg) ? secondArg.value : t3.isStringLiteral(firstArg) ? firstArg.value : void 0;
+        const signal = { type: "toast", description: text };
+        if (/(error|danger|fail)/i.test(method) || t3.isStringLiteral(firstArg) && /error/i.test(firstArg.value)) {
+          failureSignal = signal;
+        } else {
+          successSignal = successSignal ?? signal;
+        }
+      }
+    }
+    if (t3.isIdentifier(node.callee)) {
+      const calleeName = node.callee.name;
+      if (/^set[A-Z]/.test(calleeName)) {
+        hasStateSetter = true;
+        const stateName = setterToStateName(calleeName);
+        const firstArg = node.arguments[0];
+        if (stateName && t3.isBooleanLiteral(firstArg)) {
+          if (/loading|submitting|saving|fetching|refreshing/i.test(stateName)) {
+            loadingStateBindings.add(stateName);
+          }
+          if (firstArg.value === true && !/loading|submitting|saving|fetching|refreshing/i.test(stateName)) {
+            opensModal = opensModal ?? stateName;
+          }
+        }
+      }
+      if (DESTRUCTIVE_VERB.test(calleeName)) destructive = true;
+      const nested = handlers.get(calleeName);
+      if (nested) {
+        const nestedInfo = analyzeFunctionBehavior(calleeName, nested, handlers, seen);
+        hasAwait = hasAwait || nestedInfo.appilotsInferred.isAsyncTrigger === true;
+        nativeConfirmationExpected ||= nestedInfo.nativeConfirmationExpected;
+        destructive ||= nestedInfo.destructive;
+        targetScreen = targetScreen ?? nestedInfo.targetScreen;
+        successSignal = successSignal ?? nestedInfo.successSignal;
+        failureSignal = failureSignal ?? nestedInfo.failureSignal;
+        opensModal = opensModal ?? nestedInfo.opensModal;
+        for (const binding of nestedInfo.loadingStateBindings ?? []) {
+          loadingStateBindings.add(binding);
+        }
+      }
+    }
+  };
+  const inspectNode = (node) => {
+    if (t3.isAwaitExpression(node)) hasAwait = true;
+    if (t3.isCallExpression(node)) inspectCall(node);
+    if (t3.isMemberExpression(node) && t3.isIdentifier(node.property) && DESTRUCTIVE_VERB.test(node.property.name)) {
+      destructive = true;
+    }
+  };
+  if (fn.body) {
+    (0, import_traverse2.default)(fn.body, {
+      noScope: true,
+      enter: (nodePath) => inspectNode(nodePath.node)
+    });
+  }
+  const expectedOutcome = targetScreen ? "navigation" : successSignal?.type === "goBack" ? "navigation" : hasStateSetter || successSignal?.type === "toast" || opensModal ? "inline-feedback" : hasAwait || hasThen ? "mixed" : "none";
+  return {
+    appilotsInferred: {
+      isAsyncTrigger: hasAwait || hasThen || void 0,
+      expectedOutcome,
+      ...loadingStateBindings.size > 0 ? { loadingStateBindings: Array.from(loadingStateBindings).sort() } : {}
+    },
+    destructive,
+    nativeConfirmationExpected,
+    targetScreen,
+    successSignal,
+    failureSignal,
+    opensModal,
+    loadingStateBindings: Array.from(loadingStateBindings).sort()
+  };
+}
+function setterToStateName(setterName) {
+  const raw = setterName.replace(/^set/, "");
+  if (!raw) return void 0;
+  return raw.charAt(0).toLowerCase() + raw.slice(1);
+}
+
+// src/ast/navigation/calls.ts
+var import_traverse3 = __toESM(require("@babel/traverse"));
+var t4 = __toESM(require("@babel/types"));
+function extractNavigationCalls(ast) {
+  const calls = [];
+  (0, import_traverse3.default)(ast, {
+    noScope: !t4.isFile(ast),
+    CallExpression: (nodePath) => {
+      const node = nodePath.node;
+      if (!t4.isMemberExpression(node.callee) || !t4.isIdentifier(node.callee.object) || node.callee.object.name !== "navigation" || !t4.isIdentifier(node.callee.property)) {
+        return;
+      }
+      const method = node.callee.property.name;
+      if (!["navigate", "push", "replace", "goBack"].includes(method)) return;
+      const firstArg = node.arguments[0];
+      const targetScreen = t4.isStringLiteral(firstArg) ? firstArg.value : void 0;
+      calls.push({
+        method,
+        ...targetScreen ? { targetScreen } : {},
+        params: extractNavigationParams(node.arguments[1])
+      });
+    }
+  });
+  return calls;
+}
+function extractNavigationParams(arg) {
+  const params = {};
+  if (!arg || !t4.isObjectExpression(arg)) return params;
+  for (const prop of arg.properties) {
+    if (!t4.isObjectProperty(prop)) continue;
+    const key = t4.isIdentifier(prop.key) ? prop.key.name : t4.isStringLiteral(prop.key) ? prop.key.value : void 0;
+    if (!key) continue;
+    if (t4.isMemberExpression(prop.value) && t4.isIdentifier(prop.value.object) && t4.isIdentifier(prop.value.property)) {
+      params[key] = `${prop.value.object.name}.${prop.value.property.name}`;
+    } else if (t4.isIdentifier(prop.value)) {
+      params[key] = prop.value.name;
+    } else if (t4.isStringLiteral(prop.value)) {
+      params[key] = prop.value.value;
+    }
+  }
+  return params;
+}
+
+// src/extractors/appilots/jsdoc.ts
+function extractPermissionsFromJsDoc(source) {
+  if (!source.includes("@appilots-")) return void 0;
+  const result = {};
+  let touched = false;
+  const permRe = /@appilots-permissions\s+([^\n]+)/g;
+  let m;
+  while (m = permRe.exec(source)) {
+    const rawLine = (m[1] ?? "").replace(/\*\/?\s*$/, "").trim();
+    const parsed = parsePermissionLine(rawLine);
+    if (parsed) {
+      Object.assign(result, parsed);
+      touched = true;
+      break;
+    }
+  }
+  if (/@appilots-pii\b/.test(source)) {
+    result.isPii = true;
+    touched = true;
+  }
+  const blockedRe = /@appilots-blocked-actions\s+([^\n]+)/;
+  const blockedMatch = blockedRe.exec(source);
+  if (blockedMatch && blockedMatch[1]) {
+    const ids = blockedMatch[1].replace(/\*\/?\s*$/, "").split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+    if (ids.length > 0) {
+      result.blockedActions = ids;
+      touched = true;
+    }
+  }
+  return touched ? result : void 0;
+}
+function extractDestructiveJsDocTargets(source) {
+  if (!/@appilots-destructive\b/.test(source)) return void 0;
+  const out = /* @__PURE__ */ new Set();
+  const re = /@appilots-destructive\s*([^\n]*)/g;
+  let bareSeen = false;
+  let m;
+  while (m = re.exec(source)) {
+    const rest = (m[1] ?? "").replace(/\*\/?\s*$/, "").trim();
+    if (!rest) {
+      bareSeen = true;
+      continue;
+    }
+    for (const id of rest.split(/[,\s]+/).map((s) => s.trim()).filter(Boolean)) {
+      out.add(id);
+    }
+  }
+  if (out.size === 0) return bareSeen ? "*" : void 0;
+  return out;
+}
+function parsePermissionLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("{")) {
+    const candidate = trimmed.replace(/'/g, '"');
+    try {
+      const obj = JSON.parse(candidate);
+      if (obj && typeof obj === "object") {
+        return sanitisePermissionsObject(obj);
+      }
+    } catch {
+    }
+  }
+  const out = {};
+  for (const pair of trimmed.split(/[,\s]+/)) {
+    const [k, v] = pair.split("=");
+    if (!k || v === void 0) continue;
+    const key = k.trim();
+    const value = v.trim().replace(/^['"]|['"]$/g, "");
+    if (value === "true") out[key] = true;
+    else if (value === "false") out[key] = false;
+    else out[key] = value;
+  }
+  return Object.keys(out).length > 0 ? sanitisePermissionsObject(out) : null;
+}
+function sanitisePermissionsObject(obj) {
+  const out = {};
+  if (typeof obj.agentAccess === "string" && (obj.agentAccess === "read" || obj.agentAccess === "write" || obj.agentAccess === "none")) {
+    out.agentAccess = obj.agentAccess;
+  }
+  if (typeof obj.requiresConfirmation === "boolean") {
+    out.requiresConfirmation = obj.requiresConfirmation;
+  }
+  if (typeof obj.isPii === "boolean") {
+    out.isPii = obj.isPii;
+  }
+  if (Array.isArray(obj.blockedActions)) {
+    const ids = obj.blockedActions.filter((x) => typeof x === "string" && !!x);
+    if (ids.length > 0) out.blockedActions = ids;
+  }
+  return out;
+}
+
+// src/analyzers/ScreenAnalyzer.ts
+var ScreenAnalyzer = class {
+  config;
+  verbose = process.env.VERBOSE === "true";
+  /** When true, only files with registerScreen or matching screen patterns are included */
+  strictScreens;
+  /** Glob patterns that identify screen files in strict mode */
+  screenPatterns;
+  /** §D: Count of screens filtered out in strict mode (available after analyze()) */
+  screensFilteredOut = 0;
+  constructor(config, options) {
+    this.config = config;
+    this.strictScreens = options?.strictScreens ?? false;
+    this.screenPatterns = options?.screenPatterns ?? [
+      "**/*Screen.{ts,tsx}",
+      "**/screens/**/*.{ts,tsx}"
+    ];
+  }
+  /** Analyze all screens in the project */
+  async analyze() {
+    const { include = ["src/**/*Screen.{ts,tsx}"], exclude = ["node_modules/**"] } = this.config;
+    if (this.verbose) {
+      console.log(`[ScreenAnalyzer] Searching with patterns:`, include);
+      if (this.strictScreens) {
+        console.log(`[ScreenAnalyzer] Strict mode ON \u2014 screen patterns:`, this.screenPatterns);
+      }
+    }
+    const files = await (0, import_fast_glob.default)(include, {
+      cwd: this.config.rootDir,
+      ignore: exclude
+    });
+    if (this.verbose) {
+      console.log(`[ScreenAnalyzer] Found ${files.length} files`);
+    }
+    let screenPatternFiles = null;
+    if (this.strictScreens) {
+      const matched = await (0, import_fast_glob.default)(this.screenPatterns, {
+        cwd: this.config.rootDir,
+        ignore: exclude
+      });
+      screenPatternFiles = new Set(matched.map((f) => import_path3.default.resolve(this.config.rootDir, f)));
+    }
+    const screens = [];
+    this.screensFilteredOut = 0;
+    for (const file of files) {
+      const filePath = import_path3.default.resolve(this.config.rootDir, file);
+      try {
+        const descriptor = await this.analyzeFile(filePath);
+        if (!descriptor) continue;
+        if (this.strictScreens) {
+          const hasRegisterScreen = descriptor.__hasRegisterScreen === true;
+          const matchesPattern = screenPatternFiles?.has(filePath) ?? false;
+          if (!hasRegisterScreen && !matchesPattern) {
+            this.screensFilteredOut++;
+            if (this.verbose) {
+              console.log(`[ScreenAnalyzer] \u2717 Filtered (strict): ${file}`);
+            }
+            continue;
+          }
+        }
+        screens.push(descriptor);
+        if (this.verbose) {
+          console.log(`[ScreenAnalyzer] \u2713 Analyzed: ${descriptor.name} (${file})`);
+        }
+      } catch (error2) {
+        if (this.verbose) {
+          console.warn(`[ScreenAnalyzer] Failed to parse ${file}:`, error2 instanceof Error ? error2.message : error2);
+        }
+      }
+    }
+    if (this.verbose && this.strictScreens) {
+      console.log(`[ScreenAnalyzer] Strict mode: ${screens.length} included, ${this.screensFilteredOut} filtered out`);
+    }
+    return screens;
+  }
+  /** Analyze a single file. Returns descriptor + whether registerScreen was found. */
+  async analyzeFile(filePath) {
+    const source = await import_promises.default.readFile(filePath, "utf-8");
+    const name = this.extractScreenName(filePath);
+    const ast = parseSource(source, this.config.parserPlugins);
+    const registerScreenMeta = this.extractRegisterScreenMetadata(ast);
+    const hasRegisterScreenCall = this.detectRegisterScreenCall(ast);
+    const componentName = this.extractDefaultComponentName(ast);
+    const navigationTargets = this.extractNavigationTargets(ast);
+    const forms = this.mergeForms(registerScreenMeta?.forms ?? [], this.extractForms(ast));
+    const components = this.extractComponents(ast);
+    const actions = this.extractActions(ast, registerScreenMeta);
+    const collections = this.extractCollections(ast);
+    const permissionsFromJsDoc = extractPermissionsFromJsDoc(source);
+    const destructiveTags = extractDestructiveJsDocTargets(source);
+    if (destructiveTags) {
+      for (const action of actions) {
+        if (destructiveTags === "*" || destructiveTags.has(action.id)) {
+          action.destructive = true;
+        }
+      }
+    }
+    const descriptor = {
+      name: registerScreenMeta?.name || name,
+      filePath,
+      title: registerScreenMeta?.title,
+      description: registerScreenMeta?.description,
+      components,
+      forms,
+      actions,
+      navigationTargets,
+      ...collections.length > 0 ? { collections } : {},
+      ...registerScreenMeta?.suggestedPrompts && registerScreenMeta.suggestedPrompts.length > 0 ? { suggestedPrompts: registerScreenMeta.suggestedPrompts } : {},
+      ...permissionsFromJsDoc ? {
+        permissions: permissionsFromJsDoc,
+        ...permissionsFromJsDoc.isPii ? { isPii: true } : {}
+      } : {}
+    };
+    descriptor.__hasRegisterScreen = hasRegisterScreenCall;
+    return descriptor;
+  }
+  /**
+   * §B: Detect actual presence of registerScreen() call in the AST.
+   * This is more reliable than checking for title/description which are optional.
+   */
+  detectRegisterScreenCall(ast) {
+    let found = false;
+    (0, import_traverse4.default)(ast, {
+      CallExpression: (nodePath) => {
+        if (found) return;
+        const callee = nodePath.node.callee;
+        if (BabelTypes.isIdentifier(callee) && callee.name === "registerScreen" || BabelTypes.isMemberExpression(callee) && BabelTypes.isIdentifier(callee.property) && callee.property.name === "registerScreen") {
+          found = true;
+          nodePath.stop();
+        }
+      }
+    });
+    return found;
+  }
+  /**
+   * Extract metadata from registerScreen() call
+   */
+  extractRegisterScreenMetadata(ast) {
+    let metadata = null;
+    (0, import_traverse4.default)(ast, {
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (BabelTypes.isIdentifier(callee) && callee.name === "registerScreen" || BabelTypes.isMemberExpression(callee) && BabelTypes.isIdentifier(callee.property) && callee.property.name === "registerScreen") {
+          const arg = nodePath.node.arguments[0];
+          if (BabelTypes.isObjectExpression(arg)) {
+            metadata = this.parseRegisterScreenObject(arg);
+          }
+        }
+      }
+    });
+    return metadata;
+  }
+  /**
+   * Parse the object passed to registerScreen()
+   */
+  parseRegisterScreenObject(objExpr) {
+    const result = {
+      name: "",
+      actions: [],
+      forms: [],
+      navigationTargets: [],
+      components: []
+    };
+    for (const prop of objExpr.properties) {
+      if (!BabelTypes.isObjectProperty(prop) && !BabelTypes.isObjectMethod(prop)) {
+        continue;
+      }
+      const key = BabelTypes.isIdentifier(prop.key) ? prop.key.name : null;
+      if (!key) continue;
+      if (BabelTypes.isObjectProperty(prop)) {
+        const value = prop.value;
+        if (key === "name" && BabelTypes.isStringLiteral(value)) {
+          result.name = value.value;
+        } else if (key === "title" && BabelTypes.isStringLiteral(value)) {
+          result.title = value.value;
+        } else if (key === "description" && BabelTypes.isStringLiteral(value)) {
+          result.description = value.value;
+        } else if (key === "actions" && BabelTypes.isArrayExpression(value)) {
+          result.actions = this.parseActionsArray(value);
+        } else if (key === "fields" && BabelTypes.isArrayExpression(value)) {
+          const fields = this.parseFieldsArray(value);
+          if (fields.length > 0) {
+            result.forms = [
+              {
+                id: "default",
+                fields
+              }
+            ];
+          }
+        } else if (key === "suggestedPrompts" && BabelTypes.isArrayExpression(value)) {
+          const prompts = [];
+          for (const element of value.elements) {
+            if (BabelTypes.isStringLiteral(element)) {
+              const trimmed = element.value.trim();
+              if (trimmed.length > 0) prompts.push(trimmed);
+            }
+          }
+          if (prompts.length > 0) {
+            result.suggestedPrompts = prompts;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Parse actions array from registerScreen
+   */
+  parseActionsArray(arr) {
+    const actions = [];
+    for (const element of arr.elements) {
+      if (BabelTypes.isObjectExpression(element)) {
+        const action = this.parseActionObject(element);
+        if (action.id) {
+          actions.push(action);
+        }
+      }
+    }
+    return actions;
+  }
+  /**
+   * Parse a single action object
+   */
+  parseActionObject(obj) {
+    const action = {
+      id: "",
+      type: "custom"
+    };
+    for (const prop of obj.properties) {
+      if (!BabelTypes.isObjectProperty(prop)) continue;
+      const key = BabelTypes.isIdentifier(prop.key) ? prop.key.name : null;
+      if (!key) continue;
+      const value = prop.value;
+      if (key === "id" && BabelTypes.isStringLiteral(value)) {
+        action.id = value.value;
+      } else if (key === "label" && BabelTypes.isStringLiteral(value)) {
+        action.label = value.value;
+      } else if (key === "type" && BabelTypes.isStringLiteral(value)) {
+        action.type = value.value || "custom";
+      } else if (key === "targetScreen" && BabelTypes.isStringLiteral(value)) {
+        action.targetScreen = value.value;
+      } else if (key === "description" && BabelTypes.isStringLiteral(value)) {
+        action.description = value.value;
+      } else if (key === "handler" && BabelTypes.isStringLiteral(value)) {
+        action.handler = value.value;
+      } else if (key === "requiresConfirmation" && BabelTypes.isBooleanLiteral(value)) {
+        action.requiresConfirmation = value.value;
+      } else if (key === "destructive" && BabelTypes.isBooleanLiteral(value)) {
+        action.destructive = value.value;
+      } else if (key === "effect" && BabelTypes.isStringLiteral(value)) {
+        action.effect = value.value;
+      } else if (key === "riskLevel" && BabelTypes.isStringLiteral(value)) {
+        action.riskLevel = value.value;
+      } else if (key === "nativeConfirmationExpected" && BabelTypes.isBooleanLiteral(value)) {
+        action.nativeConfirmationExpected = value.value;
+      } else if (key === "appilotsInferred" && BabelTypes.isObjectExpression(value)) {
+        action.appilotsInferred = this.parseAppilotsInferredObject(value);
+      }
+    }
+    return action;
+  }
+  parseAppilotsInferredObject(obj) {
+    const out = {};
+    for (const prop of obj.properties) {
+      if (!BabelTypes.isObjectProperty(prop)) continue;
+      const key = BabelTypes.isIdentifier(prop.key) ? prop.key.name : null;
+      if (!key) continue;
+      const value = prop.value;
+      if (key === "isAsyncTrigger" && BabelTypes.isBooleanLiteral(value)) {
+        out.isAsyncTrigger = value.value;
+      } else if (key === "expectedOutcome" && BabelTypes.isStringLiteral(value)) {
+        out.expectedOutcome = value.value;
+      } else if (key === "loadingStateBindings" && BabelTypes.isArrayExpression(value)) {
+        out.loadingStateBindings = value.elements.filter((el) => BabelTypes.isStringLiteral(el)).map((el) => el.value);
+      }
+    }
+    return out;
+  }
+  /**
+   * Parse fields array from registerScreen
+   */
+  parseFieldsArray(arr) {
+    const fields = [];
+    for (const element of arr.elements) {
+      if (BabelTypes.isObjectExpression(element)) {
+        const field = this.parseFieldObject(element);
+        if (field.name) {
+          fields.push(field);
+        }
+      }
+    }
+    return fields;
+  }
+  /**
+   * Parse a single field object
+   */
+  parseFieldObject(obj) {
+    const field = {
+      name: "",
+      type: "text",
+      required: false
+    };
+    for (const prop of obj.properties) {
+      if (!BabelTypes.isObjectProperty(prop)) continue;
+      const key = BabelTypes.isIdentifier(prop.key) ? prop.key.name : null;
+      if (!key) continue;
+      const value = prop.value;
+      if (key === "id" && BabelTypes.isStringLiteral(value)) {
+        field.name = value.value;
+      } else if (key === "label" && BabelTypes.isStringLiteral(value)) {
+        field.label = value.value;
+      } else if (key === "type" && BabelTypes.isStringLiteral(value)) {
+        field.type = value.value || "text";
+      } else if (key === "required" && BabelTypes.isBooleanLiteral(value)) {
+        field.required = value.value;
+      } else if (key === "placeholder" && BabelTypes.isStringLiteral(value)) {
+        field.placeholder = value.value;
+      } else if (key === "defaultValue" && BabelTypes.isExpression(value)) {
+        field.defaultValue = this.extractLiteralValue(value);
+      } else if (key === "options" && BabelTypes.isArrayExpression(value)) {
+        field.options = this.parseOptionsArray(value);
+      }
+    }
+    return field;
+  }
+  /**
+   * Parse options array for select fields
+   */
+  parseOptionsArray(arr) {
+    const options = [];
+    for (const element of arr.elements) {
+      if (BabelTypes.isObjectExpression(element)) {
+        let label = "";
+        let value = "";
+        for (const prop of element.properties) {
+          if (!BabelTypes.isObjectProperty(prop)) continue;
+          const key = BabelTypes.isIdentifier(prop.key) ? prop.key.name : null;
+          if (!key) continue;
+          if (key === "label" && BabelTypes.isStringLiteral(prop.value)) {
+            label = prop.value.value;
+          } else if (key === "value" && BabelTypes.isStringLiteral(prop.value)) {
+            value = prop.value.value;
+          }
+        }
+        if (label && value) {
+          options.push({ label, value });
+        }
+      }
+    }
+    return options;
+  }
+  mergeForms(primary, secondary) {
+    const out = primary.map((form) => ({
+      ...form,
+      fields: [...form.fields]
+    }));
+    for (const form of secondary) {
+      const existing = out.find((candidate) => candidate.id === form.id) ?? this.findFormWithSharedFields(out, form);
+      if (!existing) {
+        out.push({ ...form, fields: [...form.fields], submitAction: this.namedSubmitAction(form.submitAction) });
+        continue;
+      }
+      for (const field of form.fields) {
+        const existingField = this.findEquivalentField(existing.fields, field);
+        if (existingField) {
+          this.mergeFieldMetadata(existingField, field);
+        } else {
+          existing.fields.push(field);
+        }
+      }
+      existing.submitAction = existing.submitAction ?? this.namedSubmitAction(form.submitAction);
+      existing.validationRules = form.validationRules ? { ...form.validationRules, ...existing.validationRules ?? {} } : existing.validationRules;
+    }
+    return out;
+  }
+  findEquivalentField(fields, incoming) {
+    return fields.find((field) => {
+      if (field.name && incoming.name && field.name === incoming.name) return true;
+      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding) return true;
+      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id) return true;
+      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder) return true;
+      if (field.locator?.accessibilityLabel && incoming.locator?.accessibilityLabel && field.locator.accessibilityLabel === incoming.locator.accessibilityLabel) {
+        return true;
+      }
+      return false;
+    });
+  }
+  namedSubmitAction(submitAction) {
+    return submitAction && submitAction !== "anonymous" ? submitAction : void 0;
+  }
+  mergeFieldMetadata(target, source) {
+    if (this.isWeakInferredFieldName(target.name) && !this.isWeakInferredFieldName(source.name)) {
+      target.name = source.name;
+    }
+    target.label = target.label ?? source.label;
+    target.placeholder = target.placeholder ?? source.placeholder;
+    target.options = target.options ?? source.options;
+    target.locator = target.locator ?? source.locator;
+    if (target.locator && source.locator) {
+      target.locator = this.mergeLocator(source.locator, target.locator);
+    }
+    target.sourceComponent = target.sourceComponent ?? source.sourceComponent;
+    target.valueBinding = target.valueBinding ?? source.valueBinding;
+    target.errorBinding = target.errorBinding ?? source.errorBinding;
+    target.required = target.required || source.required;
+    if (target.type === "text" && source.type !== "text") {
+      target.type = source.type;
+    }
+  }
+  findFormWithSharedFields(forms, incoming) {
+    if (incoming.fields.length === 0) return void 0;
+    let best;
+    for (const form of forms) {
+      const overlap = incoming.fields.filter(
+        (field) => this.findEquivalentField(form.fields, field)
+      ).length;
+      if (overlap > 0 && (!best || overlap > best.overlap)) {
+        best = { form, overlap };
+      }
+    }
+    return best?.form;
+  }
+  /**
+   * Extract the name of the default exported component
+   */
+  extractDefaultComponentName(ast) {
+    let componentName = "";
+    (0, import_traverse4.default)(ast, {
+      ExportDefaultDeclaration: (nodePath) => {
+        const declaration = nodePath.node.declaration;
+        if (BabelTypes.isFunctionDeclaration(declaration) && declaration.id?.name) {
+          componentName = declaration.id.name;
+        } else if (BabelTypes.isArrowFunctionExpression(declaration)) {
+          componentName = "Component";
+        }
+      },
+      VariableDeclarator: (nodePath) => {
+        if (BabelTypes.isIdentifier(nodePath.node.id) && (BabelTypes.isArrowFunctionExpression(nodePath.node.init) || BabelTypes.isFunctionExpression(nodePath.node.init))) {
+          const parent = nodePath.parent;
+          if (BabelTypes.isVariableDeclaration(parent) && parent.declare === true) {
+            componentName = nodePath.node.id.name;
+          }
+        }
+      }
+    });
+    return componentName;
+  }
+  /**
+   * Extract navigation targets from navigation.navigate() calls
+   */
+  extractNavigationTargets(ast) {
+    const targets = /* @__PURE__ */ new Set();
+    (0, import_traverse4.default)(ast, {
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (BabelTypes.isMemberExpression(callee) && BabelTypes.isIdentifier(callee.object) && callee.object.name === "navigation" && BabelTypes.isIdentifier(callee.property) && callee.property.name === "navigate") {
+          const arg = nodePath.node.arguments[0];
+          if (BabelTypes.isStringLiteral(arg)) {
+            targets.add(arg.value);
+          }
+        }
+      }
+    });
+    return Array.from(targets).sort();
+  }
+  /**
+   * Extract form information from JSX
+   */
+  extractForms(ast) {
+    const forms = [];
+    const fields = /* @__PURE__ */ new Map();
+    (0, import_traverse4.default)(ast, {
+      JSXOpeningElement: (nodePath) => {
+        const element = nodePath.node;
+        if (BabelTypes.isJSXIdentifier(element.name)) {
+          const componentName = element.name.name;
+          const role = classifyJsxComponent(componentName, element);
+          if (["input", "select", "toggle", "date"].includes(role)) {
+            const field = this.extractFieldFromInputElement(element);
+            if (field.name) {
+              fields.set(field.name, field);
+            }
+          }
+        }
+      }
+    });
+    if (fields.size > 0) {
+      forms.push({
+        id: "default",
+        fields: Array.from(fields.values())
+      });
+    }
+    return forms;
+  }
+  /**
+   * Extract field metadata from a TextInput/Input element
+   */
+  extractFieldFromInputElement(element) {
+    const field = {
+      name: "",
+      type: "text",
+      required: false
+    };
+    const componentName = BabelTypes.isJSXIdentifier(element.name) ? element.name.name : "";
+    const role = componentName ? classifyJsxComponent(componentName, element) : "custom";
+    field.sourceComponent = componentName || void 0;
+    for (const attr of element.attributes) {
+      if (!BabelTypes.isJSXAttribute(attr)) continue;
+      const attrName = BabelTypes.isJSXIdentifier(attr.name) ? attr.name.name : null;
+      if (!attrName) continue;
+      if (attr.value) {
+        if (BabelTypes.isStringLiteral(attr.value)) {
+          if (attrName === "placeholder") {
+            field.placeholder = attr.value.value;
+          } else if (attrName === "appilotsId") {
+            field.name = attr.value.value;
+            field.locator = this.mergeLocator(field.locator, {
+              id: attr.value.value,
+              appilotsId: attr.value.value,
+              source: "appilotsId"
+            });
+          } else if (attrName === "testID") {
+            if (!field.name) {
+              field.name = attr.value.value.replace(/^(input-|field-|txt-)/, "");
+            }
+            field.locator = this.mergeLocator(field.locator, {
+              id: field.name || attr.value.value,
+              testID: attr.value.value,
+              source: "testID"
+            });
+          } else if (attrName === "label") {
+            field.label = attr.value.value;
+          } else if (attrName === "accessibilityLabel") {
+            if (!field.label) field.label = attr.value.value;
+            field.locator = this.mergeLocator(field.locator, {
+              ...field.locator?.id ? {} : { id: this.slugifyActionId(attr.value.value) },
+              accessibilityLabel: attr.value.value,
+              source: field.locator?.source ?? "accessibilityLabel"
+            });
+          } else if (attrName === "keyboardType") {
+            if (attr.value.value === "email-address" || attr.value.value === "email") field.type = "email";
+            if (attr.value.value === "phone-pad") field.type = "phone";
+            if (attr.value.value === "numeric" || attr.value.value === "number-pad") field.type = "number";
+          }
+        } else if (BabelTypes.isJSXExpressionContainer(attr.value)) {
+          if (attrName === "value" && BabelTypes.isIdentifier(attr.value.expression)) {
+            if (!field.name) {
+              field.name = attr.value.expression.name;
+            }
+            field.valueBinding = attr.value.expression.name;
+          } else if (attrName === "checked" && BabelTypes.isIdentifier(attr.value.expression)) {
+            if (!field.name) field.name = attr.value.expression.name;
+            field.valueBinding = attr.value.expression.name;
+          } else if (attrName === "error") {
+            field.errorBinding = this.expressionToBinding(attr.value.expression);
+          } else if (attrName === "required" && BabelTypes.isBooleanLiteral(attr.value.expression)) {
+            field.required = attr.value.expression.value;
+          }
+        }
+      } else if (attrName === "required") {
+        field.required = true;
+      }
+    }
+    if (role === "select") field.type = "select";
+    if (role === "toggle") field.type = "toggle";
+    if (role === "date") field.type = "date";
+    if (!field.name || this.isWeakInferredFieldName(field.name)) {
+      const label = field.locator?.accessibilityLabel ?? field.label ?? field.placeholder;
+      if (label) field.name = this.slugifyActionId(label);
+    }
+    if (!field.locator && field.name) {
+      field.locator = { id: field.name, label: field.label, source: "inferred" };
+    } else if (field.locator && !field.locator.id && field.name) {
+      field.locator = this.mergeLocator(field.locator, {
+        id: field.name,
+        label: field.label,
+        source: field.locator.source ?? "inferred"
+      });
+    }
+    return field;
+  }
+  isWeakInferredFieldName(name) {
+    return /^(text|value|input|query|search|selected|checked)$/i.test(name);
+  }
+  /**
+   * Extract component structure from JSX
+   */
+  extractComponents(ast) {
+    const components = [];
+    const seen = /* @__PURE__ */ new Set();
+    (0, import_traverse4.default)(ast, {
+      JSXOpeningElement: (nodePath) => {
+        const element = nodePath.node;
+        if (BabelTypes.isJSXIdentifier(element.name)) {
+          const componentName = element.name.name;
+          if (seen.has(componentName)) return;
+          seen.add(componentName);
+          const type = this.inferComponentType(componentName);
+          const component = {
+            name: componentName,
+            type
+          };
+          for (const attr of element.attributes) {
+            if (!BabelTypes.isJSXAttribute(attr)) continue;
+            const attrName = BabelTypes.isJSXIdentifier(attr.name) ? attr.name.name : null;
+            if (!attrName) continue;
+            if (attr.value && BabelTypes.isStringLiteral(attr.value)) {
+              if (attrName === "testID") {
+                component.testID = attr.value.value;
+              } else if (attrName === "accessibilityLabel") {
+                component.accessibilityLabel = attr.value.value;
+              }
+            }
+          }
+          components.push(component);
+        }
+      }
+    });
+    return components;
+  }
+  /**
+   * Infer component type from component name
+   */
+  inferComponentType(name) {
+    const role = classifyJsxComponent(name);
+    if (role === "select" || role === "toggle" || role === "date") {
+      return "input";
+    }
+    if (role === "input") {
+      return "input";
+    }
+    if (role === "button") {
+      return "button";
+    }
+    if (role === "list") {
+      return "list";
+    }
+    if (role === "modal") {
+      return "modal";
+    }
+    if (role === "view") {
+      return "view";
+    }
+    return "custom";
+  }
+  /**
+   * Extract actions from button/touchable elements
+   */
+  extractActions(ast, registerScreenMeta) {
+    const actions = [...registerScreenMeta?.actions || []];
+    const actionIds = new Set(actions.map((a) => a.id));
+    const actionLabels = new Map(
+      actions.filter((a) => a.label).map((a) => [this.normalizeLabel(a.label), a])
+    );
+    (0, import_traverse4.default)(ast, {
+      JSXOpeningElement: (nodePath) => {
+        const element = nodePath.node;
+        if (BabelTypes.isJSXIdentifier(element.name)) {
+          const componentName = element.name.name;
+          if (classifyJsxComponent(componentName, element) === "button") {
+            const action = this.extractActionFromButton(element);
+            const existingByLabel = action.label ? actionLabels.get(this.normalizeLabel(action.label)) : void 0;
+            if (existingByLabel) {
+              this.mergeActionMetadata(existingByLabel, action);
+              return;
+            }
+            if (action.id && !actionIds.has(action.id)) {
+              actions.push(action);
+              actionIds.add(action.id);
+              if (action.label) actionLabels.set(this.normalizeLabel(action.label), action);
+            }
+          }
+        }
+      }
+    });
+    this.enrichActionsFromHandlers(ast, actions);
+    return actions;
+  }
+  normalizeLabel(label) {
+    return label.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]/g, "");
+  }
+  mergeActionMetadata(target, source) {
+    target.handler = target.handler ?? source.handler;
+    target.targetScreen = target.targetScreen ?? source.targetScreen;
+    target.description = target.description ?? source.description;
+    target.nativeConfirmationExpected = target.nativeConfirmationExpected || source.nativeConfirmationExpected || void 0;
+    target.requiresConfirmation = target.requiresConfirmation || source.requiresConfirmation || void 0;
+    target.destructive = target.destructive || source.destructive || void 0;
+    target.effect = target.effect ?? source.effect;
+    target.riskLevel = target.riskLevel ?? source.riskLevel;
+    target.appilotsInferred = target.appilotsInferred ?? source.appilotsInferred;
+  }
+  enrichActionsFromHandlers(ast, actions) {
+    const handlerMap = this.collectHandlerInfo(ast);
+    const labelToHandler = this.collectButtonHandlersByLabel(ast);
+    for (const action of actions) {
+      if (!action.handler && action.label) {
+        const handler2 = labelToHandler.get(action.label);
+        if (handler2) action.handler = handler2;
+      }
+      const handler = action.handler ? handlerMap.get(action.handler) : void 0;
+      if (!handler) continue;
+      action.appilotsInferred = {
+        ...action.appilotsInferred ?? {},
+        ...handler.appilotsInferred
+      };
+      if (handler.nativeConfirmationExpected) action.nativeConfirmationExpected = true;
+      if (handler.targetScreen && !action.targetScreen) action.targetScreen = handler.targetScreen;
+      if (handler.successSignal && !action.successSignal) action.successSignal = handler.successSignal;
+      if (handler.failureSignal && !action.failureSignal) action.failureSignal = handler.failureSignal;
+      if (handler.opensModal && !action.opensModal) action.opensModal = handler.opensModal;
+      if (handler.destructive || action.destructive === true || action.requiresConfirmation === true || action.effect === "destructive" || action.riskLevel === "high") {
+        action.destructive = true;
+        action.effect = action.effect ?? "destructive";
+        action.riskLevel = action.riskLevel ?? "high";
+        action.requiresConfirmation = action.requiresConfirmation ?? true;
+      }
+    }
+  }
+  collectButtonHandlersByLabel(ast) {
+    const out = /* @__PURE__ */ new Map();
+    (0, import_traverse4.default)(ast, {
+      JSXOpeningElement: (nodePath) => {
+        const element = nodePath.node;
+        if (!BabelTypes.isJSXIdentifier(element.name)) return;
+        const componentName = element.name.name;
+        if (classifyJsxComponent(componentName, element) !== "button") return;
+        let label;
+        let handler;
+        for (const attr of element.attributes) {
+          if (!BabelTypes.isJSXAttribute(attr)) continue;
+          const attrName = BabelTypes.isJSXIdentifier(attr.name) ? attr.name.name : null;
+          if (!attrName || !attr.value) continue;
+          if ((attrName === "title" || attrName === "accessibilityLabel" || attrName === "label") && BabelTypes.isStringLiteral(attr.value)) {
+            label = attr.value.value;
+          }
+          if (attrName === "onPress" && BabelTypes.isJSXExpressionContainer(attr.value) && BabelTypes.isIdentifier(attr.value.expression)) {
+            handler = attr.value.expression.name;
+          }
+        }
+        if (label && handler) out.set(label, handler);
+      }
+    });
+    return out;
+  }
+  collectHandlerInfo(ast) {
+    const handlers = collectFunctions(ast);
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, fn] of handlers) {
+      const info2 = analyzeFunctionBehavior(name, fn, handlers);
+      out.set(name, info2);
+    }
+    return out;
+  }
+  analyzeHandlerFunction(name, fn, handlers, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(name)) {
+      return {
+        appilotsInferred: { expectedOutcome: "none" },
+        destructive: false,
+        nativeConfirmationExpected: false
+      };
+    }
+    seen.add(name);
+    let hasAwait = fn.async === true;
+    let hasThen = false;
+    let hasStateSetter = false;
+    let nativeConfirmationExpected = false;
+    let targetScreen;
+    let destructive = /(delete|destroy|remove|discard|wipe|drop|terminate)/i.test(name);
+    const inspectNode = (node) => {
+      if (BabelTypes.isAwaitExpression(node)) hasAwait = true;
+      if (BabelTypes.isCallExpression(node) && BabelTypes.isMemberExpression(node.callee) && BabelTypes.isIdentifier(node.callee.property)) {
+        const method = node.callee.property.name;
+        if (method === "then" || method === "catch" || method === "finally") hasThen = true;
+        if (BabelTypes.isIdentifier(node.callee.object) && node.callee.object.name === "navigation" && ["navigate", "push", "replace"].includes(method)) {
+          const firstArg = node.arguments[0];
+          if (BabelTypes.isStringLiteral(firstArg)) targetScreen = firstArg.value;
+        }
+        if (BabelTypes.isIdentifier(node.callee.object) && node.callee.object.name === "Alert" && method === "alert") {
+          nativeConfirmationExpected = true;
+        }
+      }
+      if (BabelTypes.isCallExpression(node) && BabelTypes.isIdentifier(node.callee)) {
+        const calleeName = node.callee.name;
+        if (/^set[A-Z]/.test(calleeName)) hasStateSetter = true;
+        if (/(delete|destroy|remove|discard|wipe|drop|terminate)/i.test(calleeName)) {
+          destructive = true;
+        }
+        const nested = handlers.get(calleeName);
+        if (nested) {
+          const nestedInfo = this.analyzeHandlerFunction(calleeName, nested, handlers, seen);
+          hasAwait = hasAwait || nestedInfo.appilotsInferred.isAsyncTrigger === true;
+          nativeConfirmationExpected ||= nestedInfo.nativeConfirmationExpected;
+          destructive ||= nestedInfo.destructive;
+          targetScreen = targetScreen ?? nestedInfo.targetScreen;
+        }
+      }
+      if (BabelTypes.isMemberExpression(node) && BabelTypes.isIdentifier(node.property) && /(delete|destroy|remove|discard|wipe|drop|terminate)/i.test(node.property.name)) {
+        destructive = true;
+      }
+    };
+    if (fn.body) {
+      (0, import_traverse4.default)(fn.body, {
+        noScope: true,
+        enter: (nodePath) => inspectNode(nodePath.node)
+      });
+    }
+    const expectedOutcome = targetScreen ? "navigation" : hasStateSetter ? "inline-feedback" : hasAwait || hasThen ? "mixed" : "none";
+    return {
+      appilotsInferred: {
+        isAsyncTrigger: hasAwait || hasThen || void 0,
+        expectedOutcome
+      },
+      destructive,
+      nativeConfirmationExpected,
+      targetScreen
+    };
+  }
+  /**
+   * BACKLOG 2.2 — heuristic destructive detection.
+   *
+   * Combines several signals:
+   *  - JSX `destructive` boolean prop (`<Pressable destructive />`)
+   *  - JSX `aria-destructive` attribute
+   *  - Handler name contains a generic destructive verb
+   *    (delete/destroy/remove/discard/wipe/revoke/etc.). `cancel` is intentionally excluded —
+   *    too many "Cancelar" buttons that just dismiss modals.
+   *  - testID / id contains a destructive verb
+   *
+   * Default-allow with explicit opt-out via `@appilots-non-destructive`
+   * is more dangerous than the inverse, so we default-deny: the
+   * heuristic must hit OR the JSDoc tag must be present.
+   */
+  isElementDestructive(element, handlerName, actionId) {
+    const DESTRUCTIVE_VERB2 = /(delete|destroy|remove|discard|wipe|erase|drop|terminate|revoke|deactivate|disable)/i;
+    for (const attr of element.attributes) {
+      if (!BabelTypes.isJSXAttribute(attr)) continue;
+      const attrName = BabelTypes.isJSXIdentifier(attr.name) ? attr.name.name : null;
+      if (attrName === "destructive" || attrName === "aria-destructive") {
+        if (attr.value === null) return true;
+        if (BabelTypes.isJSXExpressionContainer(attr.value)) {
+          const expr = attr.value.expression;
+          if (BabelTypes.isBooleanLiteral(expr)) return expr.value;
+        }
+        if (BabelTypes.isStringLiteral(attr.value)) {
+          return attr.value.value === "true";
+        }
+      }
+    }
+    if (handlerName && DESTRUCTIVE_VERB2.test(handlerName)) return true;
+    if (actionId && DESTRUCTIVE_VERB2.test(actionId)) return true;
+    return false;
+  }
+  /**
+   * Extract action metadata from a button element
+   */
+  extractActionFromButton(element) {
+    const action = {
+      id: "",
+      type: "custom"
+    };
+    const componentName = BabelTypes.isJSXIdentifier(element.name) ? element.name.name : void 0;
+    action.sourceComponent = componentName;
+    let handlerName;
+    for (const attr of element.attributes) {
+      if (!BabelTypes.isJSXAttribute(attr)) continue;
+      const attrName = BabelTypes.isJSXIdentifier(attr.name) ? attr.name.name : null;
+      if (!attrName) continue;
+      if (attr.value) {
+        if (BabelTypes.isStringLiteral(attr.value)) {
+          if (attrName === "appilotsId") {
+            action.id = attr.value.value;
+            action.locator = this.mergeLocator(action.locator, {
+              id: attr.value.value,
+              appilotsId: attr.value.value,
+              source: "appilotsId"
+            });
+          } else if (attrName === "testID") {
+            action.id = attr.value.value;
+            action.locator = this.mergeLocator(action.locator, {
+              id: attr.value.value,
+              testID: attr.value.value,
+              source: "testID"
+            });
+          } else if (attrName === "title" || attrName === "label" || attrName === "accessibilityLabel") {
+            action.label = attr.value.value;
+            if (attrName === "accessibilityLabel") {
+              action.locator = this.mergeLocator(action.locator, {
+                accessibilityLabel: attr.value.value,
+                source: "accessibilityLabel"
+              });
+            }
+            if (!action.id) {
+              action.id = this.slugifyActionId(attr.value.value);
+            }
+          }
+        } else if (BabelTypes.isJSXExpressionContainer(attr.value)) {
+          if (attrName === "onPress" && BabelTypes.isIdentifier(attr.value.expression)) {
+            handlerName = attr.value.expression.name.toLowerCase();
+            action.handler = attr.value.expression.name;
+            if (handlerName.includes("submit")) {
+              action.type = "submit";
+            } else if (handlerName.includes("navigate")) {
+              action.type = "navigation";
+            }
+          } else if (attrName === "onPress") {
+            const inline = this.extractInlineOnPressMetadata(attr.value.expression);
+            if (inline.handler) {
+              handlerName = inline.handler.toLowerCase();
+              action.handler = inline.handler;
+              if (handlerName.includes("submit")) action.type = "submit";
+            }
+            if (inline.targetScreen) {
+              action.type = "navigation";
+              action.targetScreen = inline.targetScreen;
+            }
+          } else if (attrName === "loading" && BabelTypes.isIdentifier(attr.value.expression)) {
+            action.appilotsInferred = {
+              ...action.appilotsInferred ?? {},
+              isAsyncTrigger: true,
+              loadingStateBindings: [attr.value.expression.name]
+            };
+          }
+        }
+      } else if (attrName === "destructive") {
+        action.destructive = true;
+      }
+    }
+    if (!action.locator && action.id) {
+      action.locator = { id: action.id, label: action.label, source: action.label ? "label" : "inferred" };
+    }
+    if (this.isElementDestructive(element, handlerName, action.id)) {
+      action.destructive = true;
+    }
+    return action;
+  }
+  extractInlineOnPressMetadata(expr) {
+    if (BabelTypes.isJSXEmptyExpression(expr)) return {};
+    const navCall = extractNavigationCalls(expr).find((call) => call.targetScreen);
+    const handler = this.extractFirstHandlerName(expr);
+    return {
+      ...handler ? { handler } : {},
+      ...navCall?.targetScreen ? { targetScreen: navCall.targetScreen } : {}
+    };
+  }
+  extractFirstHandlerName(node) {
+    if (BabelTypes.isIdentifier(node)) return node.name;
+    if (BabelTypes.isArrowFunctionExpression(node) || BabelTypes.isFunctionExpression(node)) {
+      return this.extractFirstHandlerName(node.body);
+    }
+    if (BabelTypes.isBlockStatement(node)) {
+      for (const statement of node.body) {
+        const handler = this.extractFirstHandlerName(statement);
+        if (handler) return handler;
+      }
+      return void 0;
+    }
+    if (BabelTypes.isExpressionStatement(node)) {
+      return this.extractFirstHandlerName(node.expression);
+    }
+    if (BabelTypes.isReturnStatement(node)) {
+      return node.argument ? this.extractFirstHandlerName(node.argument) : void 0;
+    }
+    if (BabelTypes.isUnaryExpression(node)) {
+      return this.extractFirstHandlerName(node.argument);
+    }
+    if (BabelTypes.isAwaitExpression(node)) {
+      return this.extractFirstHandlerName(node.argument);
+    }
+    if (BabelTypes.isCallExpression(node)) {
+      if (BabelTypes.isIdentifier(node.callee)) return node.callee.name;
+      return void 0;
+    }
+    return void 0;
+  }
+  mergeLocator(current, next) {
+    return { ...current ?? {}, ...next };
+  }
+  expressionToBinding(expr) {
+    if (BabelTypes.isIdentifier(expr)) return expr.name;
+    if (BabelTypes.isMemberExpression(expr) && BabelTypes.isIdentifier(expr.object) && BabelTypes.isIdentifier(expr.property)) {
+      return `${expr.object.name}.${expr.property.name}`;
+    }
+    return void 0;
+  }
+  slugifyActionId(label) {
+    return label.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  }
+  extractCollections(ast) {
+    const renderItemFns = this.collectRenderItemFunctions(ast);
+    const collections = [];
+    (0, import_traverse4.default)(ast, {
+      JSXOpeningElement: (nodePath) => {
+        const element = nodePath.node;
+        if (!BabelTypes.isJSXIdentifier(element.name)) return;
+        const component = element.name.name;
+        if (!["FlatList", "SectionList", "VirtualizedList", "FlashList"].includes(component)) {
+          return;
+        }
+        const dataSource = this.jsxExpressionIdentifier(element, "data");
+        const renderItem = this.jsxExpressionIdentifier(element, "renderItem");
+        const keyField = this.extractKeyField(element);
+        const renderFn = renderItem ? renderItemFns.get(renderItem) : void 0;
+        const rowAction = renderFn ? this.extractRowAction(renderFn) : void 0;
+        const displayFields = renderFn ? this.extractItemFields(renderFn) : [];
+        const itemType = this.inferItemType(dataSource, renderItem, displayFields);
+        const identityFields = this.inferIdentityFields(keyField, displayFields);
+        const searchField = this.inferSearchField(ast, dataSource);
+        const id = dataSource ?? renderItem ?? `${component.toLowerCase()}-${collections.length + 1}`;
+        collections.push({
+          id,
+          component,
+          ...itemType ? { itemType } : {},
+          ...dataSource ? { dataSource } : {},
+          ...keyField ? { keyField } : {},
+          ...renderItem ? { renderItem } : {},
+          ...displayFields.length > 0 ? { displayFields } : {},
+          ...rowAction ? { rowAction } : {},
+          ...rowAction ? { rowActions: [rowAction] } : {},
+          ...identityFields.length > 0 ? { identityFields } : {},
+          ...searchField ? { searchField } : {}
+        });
+      }
+    });
+    return collections;
+  }
+  collectRenderItemFunctions(ast) {
+    const out = /* @__PURE__ */ new Map();
+    (0, import_traverse4.default)(ast, {
+      VariableDeclarator: (nodePath) => {
+        if (!BabelTypes.isIdentifier(nodePath.node.id)) return;
+        const init = nodePath.node.init;
+        if (BabelTypes.isArrowFunctionExpression(init) || BabelTypes.isFunctionExpression(init)) {
+          out.set(nodePath.node.id.name, init);
+        }
+      },
+      FunctionDeclaration: (nodePath) => {
+        if (nodePath.node.id?.name) out.set(nodePath.node.id.name, nodePath.node);
+      }
+    });
+    return out;
+  }
+  jsxExpressionIdentifier(element, attrName) {
+    const attr = element.attributes.find(
+      (candidate) => BabelTypes.isJSXAttribute(candidate) && BabelTypes.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+    );
+    if (!BabelTypes.isJSXAttribute(attr) || !attr.value) return void 0;
+    if (BabelTypes.isJSXExpressionContainer(attr.value) && BabelTypes.isIdentifier(attr.value.expression)) {
+      return attr.value.expression.name;
+    }
+    if (BabelTypes.isStringLiteral(attr.value)) return attr.value.value;
+    return void 0;
+  }
+  extractKeyField(element) {
+    const attr = element.attributes.find(
+      (candidate) => BabelTypes.isJSXAttribute(candidate) && BabelTypes.isJSXIdentifier(candidate.name) && candidate.name.name === "keyExtractor"
+    );
+    if (!BabelTypes.isJSXAttribute(attr) || !attr.value || !BabelTypes.isJSXExpressionContainer(attr.value)) {
+      return void 0;
+    }
+    const expr = attr.value.expression;
+    if (!BabelTypes.isArrowFunctionExpression(expr)) return void 0;
+    const param = expr.params[0];
+    if (!BabelTypes.isIdentifier(param)) return void 0;
+    if (BabelTypes.isMemberExpression(expr.body) && BabelTypes.isIdentifier(expr.body.object) && expr.body.object.name === param.name && BabelTypes.isIdentifier(expr.body.property)) {
+      return expr.body.property.name;
+    }
+    return void 0;
+  }
+  extractRowAction(fn) {
+    let action;
+    (0, import_traverse4.default)(fn.body, {
+      noScope: true,
+      CallExpression: (nodePath) => {
+        const node = nodePath.node;
+        if (!BabelTypes.isMemberExpression(node.callee) || !BabelTypes.isIdentifier(node.callee.object) || node.callee.object.name !== "navigation" || !BabelTypes.isIdentifier(node.callee.property) || !["navigate", "push", "replace"].includes(node.callee.property.name)) {
+          return;
+        }
+        const firstArg = node.arguments[0];
+        if (!BabelTypes.isStringLiteral(firstArg)) return;
+        const params = this.extractNavigationParams(node.arguments[1]);
+        action = {
+          type: "navigation",
+          targetScreen: firstArg.value,
+          ...Object.keys(params).length > 0 ? { params } : {},
+          description: `Pressing a row opens ${firstArg.value}`
+        };
+      }
+    });
+    return action;
+  }
+  extractNavigationParams(arg) {
+    const params = {};
+    if (!arg || !BabelTypes.isObjectExpression(arg)) return params;
+    for (const prop of arg.properties) {
+      if (!BabelTypes.isObjectProperty(prop)) continue;
+      const key = BabelTypes.isIdentifier(prop.key) ? prop.key.name : BabelTypes.isStringLiteral(prop.key) ? prop.key.value : void 0;
+      if (!key) continue;
+      if (BabelTypes.isMemberExpression(prop.value) && BabelTypes.isIdentifier(prop.value.object) && BabelTypes.isIdentifier(prop.value.property)) {
+        params[key] = `${prop.value.object.name}.${prop.value.property.name}`;
+      } else if (BabelTypes.isIdentifier(prop.value)) {
+        params[key] = prop.value.name;
+      } else if (BabelTypes.isStringLiteral(prop.value)) {
+        params[key] = prop.value.value;
+      }
+    }
+    return params;
+  }
+  extractItemFields(fn) {
+    const fields = /* @__PURE__ */ new Set();
+    const itemNames = /* @__PURE__ */ new Set(["item"]);
+    const firstParam = fn.params[0];
+    if (BabelTypes.isObjectPattern(firstParam)) {
+      for (const prop of firstParam.properties) {
+        if (BabelTypes.isObjectProperty(prop) && BabelTypes.isIdentifier(prop.key) && prop.key.name === "item" && BabelTypes.isIdentifier(prop.value)) {
+          itemNames.add(prop.value.name);
+        }
+      }
+    } else if (BabelTypes.isIdentifier(firstParam)) {
+      itemNames.add(firstParam.name);
+    }
+    (0, import_traverse4.default)(fn.body, {
+      noScope: true,
+      MemberExpression: (nodePath) => {
+        const node = nodePath.node;
+        if (BabelTypes.isIdentifier(node.object) && itemNames.has(node.object.name) && BabelTypes.isIdentifier(node.property)) {
+          fields.add(node.property.name);
+        }
+      }
+    });
+    return Array.from(fields).sort();
+  }
+  inferItemType(dataSource, renderItem, displayFields) {
+    const source = dataSource ?? renderItem;
+    if (!source) return void 0;
+    const singular = source.replace(/^render/i, "").replace(/(List|Items|Data|Rows|Sections)$/i, "").replace(/s$/i, "");
+    const candidate = singular.charAt(0).toUpperCase() + singular.slice(1);
+    if (candidate.length > 1) return candidate;
+    if (displayFields.length > 0) return "Item";
+    return void 0;
+  }
+  inferIdentityFields(keyField, displayFields) {
+    const out = /* @__PURE__ */ new Set();
+    if (keyField) out.add(keyField);
+    for (const field of displayFields) {
+      if (/^(id|uuid|key|name|title|plate|email|slug)$/i.test(field)) out.add(field);
+    }
+    return Array.from(out);
+  }
+  inferSearchField(ast, dataSource) {
+    if (!dataSource) return void 0;
+    let queryBinding;
+    (0, import_traverse4.default)(ast, {
+      CallExpression: (nodePath) => {
+        const node = nodePath.node;
+        if (!BabelTypes.isMemberExpression(node.callee)) return;
+        if (!BabelTypes.isIdentifier(node.callee.property) || node.callee.property.name !== "filter") return;
+        if (!BabelTypes.isIdentifier(node.callee.object) || node.callee.object.name !== dataSource) return;
+        const fn = node.arguments[0];
+        if (!BabelTypes.isArrowFunctionExpression(fn) && !BabelTypes.isFunctionExpression(fn)) return;
+        (0, import_traverse4.default)(fn.body, {
+          noScope: true,
+          Identifier: (innerPath) => {
+            const name = innerPath.node.name;
+            if (/query|search|filter/i.test(name)) queryBinding = queryBinding ?? name;
+          }
+        });
+      }
+    });
+    return queryBinding;
+  }
+  /**
+   * Extract literal values from AST nodes
+   */
+  extractLiteralValue(node) {
+    if (BabelTypes.isStringLiteral(node)) {
+      return node.value;
+    }
+    if (BabelTypes.isNumericLiteral(node)) {
+      return node.value;
+    }
+    if (BabelTypes.isBooleanLiteral(node)) {
+      return node.value;
+    }
+    if (BabelTypes.isNullLiteral(node)) {
+      return null;
+    }
+    return void 0;
+  }
+  /**
+   * Extract screen name from file path
+   * E.g., /src/screens/ItemListScreen.tsx -> ItemListScreen
+   */
+  extractScreenName(filePath) {
+    const basename2 = import_path3.default.basename(filePath);
+    return basename2.replace(/\.(tsx?|jsx?)$/, "");
+  }
+};
+
+// src/analyzers/NavigationAnalyzer.ts
+var import_fs4 = require("fs");
+var import_path4 = __toESM(require("path"));
+var import_fast_glob2 = __toESM(require("fast-glob"));
+var parser = __toESM(require("@babel/parser"));
+var import_traverse5 = __toESM(require("@babel/traverse"));
+var t5 = __toESM(require("@babel/types"));
+var NavigationAnalyzer = class {
+  config;
+  /** Extra glob patterns for navigation file discovery (added to defaults) */
+  navigationInclude;
+  /** Extra glob patterns to exclude from navigation analysis */
+  navigationExclude;
+  constructor(config, options) {
+    this.config = config;
+    this.navigationInclude = options?.navigationInclude ?? [];
+    this.navigationExclude = options?.navigationExclude ?? [];
+  }
+  /** Build the full navigation graph */
+  async analyze() {
+    const navigationFiles = await this.findNavigationFiles();
+    const parsedNavigators = [];
+    const typeExports = [];
+    for (const filePath of navigationFiles) {
+      try {
+        const content = await import_fs4.promises.readFile(filePath, "utf-8");
+        const navigators = this.parseNavigators(content, filePath);
+        const types = this.parseParamTypes(content, filePath);
+        parsedNavigators.push(...navigators);
+        typeExports.push(...types);
+      } catch (error2) {
+        console.warn(`Failed to parse ${filePath}:`, error2);
+      }
+    }
+    this.attachParamsToNavigators(parsedNavigators, typeExports);
+    return this.buildNavigationGraph(parsedNavigators);
+  }
+  /** Find all navigation-related files */
+  async findNavigationFiles() {
+    const patterns = [
+      "**/navigation/**/*.{ts,tsx}",
+      "**/navigator*.{ts,tsx}",
+      "**/routes*.{ts,tsx}",
+      // §5: Add user-configured navigation patterns (additive, not replacing)
+      ...this.navigationInclude
+    ];
+    const excludePatterns = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      ...this.config.exclude || [],
+      // §5: Add user-configured navigation excludes
+      ...this.navigationExclude
+    ];
+    const files = await (0, import_fast_glob2.default)(patterns, {
+      cwd: this.config.rootDir,
+      ignore: excludePatterns
+    });
+    return files.map((file) => import_path4.default.join(this.config.rootDir, file));
+  }
+  /** Parse navigator definitions from a file */
+  parseNavigators(content, filePath) {
+    const navigators = [];
+    try {
+      const ast = parser.parse(content, {
+        sourceType: "module",
+        plugins: [
+          "jsx",
+          "typescript",
+          ...this.config.parserPlugins || []
+        ]
+      });
+      const navigatorCalls = /* @__PURE__ */ new Map();
+      const screensByNavigator = /* @__PURE__ */ new Map();
+      (0, import_traverse5.default)(ast, {
+        // Detect createStackNavigator / createTabNavigator / createDrawerNavigator calls
+        CallExpression: (nodePath) => {
+          const { node } = nodePath;
+          const callee = node.callee;
+          let navigatorType = null;
+          if (t5.isIdentifier(callee) && callee.name === "createNativeStackNavigator") {
+            navigatorType = "stack";
+          } else if (t5.isIdentifier(callee) && callee.name === "createStackNavigator") {
+            navigatorType = "stack";
+          } else if (t5.isIdentifier(callee) && callee.name === "createBottomTabNavigator") {
+            navigatorType = "tab";
+          } else if (t5.isIdentifier(callee) && callee.name === "createTabNavigator") {
+            navigatorType = "tab";
+          } else if (t5.isIdentifier(callee) && callee.name === "createDrawerNavigator") {
+            navigatorType = "drawer";
+          }
+          if (navigatorType) {
+            const parent = nodePath.parent;
+            if (t5.isVariableDeclarator(parent) && t5.isIdentifier(parent.id)) {
+              const varName = parent.id.name;
+              navigatorCalls.set(varName, {
+                name: varName,
+                type: navigatorType,
+                screens: []
+              });
+            }
+          }
+        },
+        // Detect Stack.Navigator / Tab.Navigator JSX elements
+        JSXElement: (nodePath) => {
+          const { node } = nodePath;
+          const openingElement = node.openingElement;
+          if (t5.isJSXMemberExpression(openingElement.name) && t5.isJSXIdentifier(openingElement.name.object)) {
+            const objectName = openingElement.name.object.name;
+            const propertyName = t5.isJSXIdentifier(openingElement.name.property) ? openingElement.name.property.name : null;
+            if (propertyName === "Navigator") {
+              const navigator = navigatorCalls.get(objectName);
+              if (navigator) {
+                const initialRouteAttr = openingElement.attributes.find(
+                  (attr) => t5.isJSXAttribute(attr) && t5.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
+                );
+                if (t5.isJSXAttribute(initialRouteAttr) && t5.isStringLiteral(initialRouteAttr.value)) {
+                  navigator.initialRouteName = initialRouteAttr.value.value;
+                }
+                const screens = this.extractScreensFromNavigator(
+                  node,
+                  objectName,
+                  navigator.type
+                );
+                screensByNavigator.set(objectName, screens);
+              }
+            }
+          }
+        }
+      });
+      navigatorCalls.forEach((navigator) => {
+        const screens = screensByNavigator.get(navigator.name) || [];
+        navigator.screens = screens;
+        navigators.push(navigator);
+      });
+    } catch (error2) {
+      console.warn(`Failed to parse navigators in ${filePath}:`, error2);
+    }
+    return navigators;
+  }
+  /** Extract screens from a navigator JSX element */
+  extractScreensFromNavigator(navigatorElement, navigatorVarName, navigatorType) {
+    const screens = [];
+    if (!navigatorElement.children) return screens;
+    for (const child of navigatorElement.children) {
+      if (t5.isJSXElement(child) && t5.isJSXMemberExpression(child.openingElement.name)) {
+        const memberExpr = child.openingElement.name;
+        if (t5.isJSXIdentifier(memberExpr.object) && memberExpr.object.name === navigatorVarName && t5.isJSXIdentifier(memberExpr.property) && memberExpr.property.name === "Screen") {
+          const screenName = this.extractAttributeValue(
+            child.openingElement.attributes,
+            "name"
+          );
+          if (screenName) {
+            screens.push({
+              name: screenName,
+              navigatorName: navigatorVarName,
+              navigatorType
+            });
+          }
+        }
+      }
+    }
+    return screens;
+  }
+  /** Extract string attribute value from JSX attributes */
+  extractAttributeValue(attributes, attrName) {
+    const attr = attributes.find(
+      (a) => t5.isJSXAttribute(a) && t5.isJSXIdentifier(a.name) && a.name.name === attrName
+    );
+    if (t5.isJSXAttribute(attr) && t5.isStringLiteral(attr.value)) {
+      return attr.value.value;
+    }
+    return null;
+  }
+  /** Parse TypeScript type exports (ParamList types) */
+  parseParamTypes(content, filePath) {
+    const types = [];
+    try {
+      const ast = parser.parse(content, {
+        sourceType: "module",
+        plugins: [
+          "jsx",
+          "typescript",
+          ...this.config.parserPlugins || []
+        ]
+      });
+      (0, import_traverse5.default)(ast, {
+        TSTypeAliasDeclaration: (nodePath) => {
+          const { node } = nodePath;
+          const typeName = node.id.name;
+          const typeMatch = /^[A-Za-z0-9_]*(Stack|Tab|Drawer)?ParamList$/i.test(typeName);
+          if (typeMatch && node.typeAnnotation?.type === "TSTypeLiteral") {
+            const paramEntries = this.extractParamListEntries(
+              node.typeAnnotation,
+              typeName
+            );
+            const navType = this.inferTypeFromName(typeName);
+            if (navType) {
+              types.push({
+                name: typeName,
+                type: navType.type,
+                paramEntries
+              });
+            }
+          }
+        }
+      });
+    } catch (error2) {
+      console.warn(`Failed to parse types in ${filePath}:`, error2);
+    }
+    return types;
+  }
+  /** Extract param entries from a TypeScript type literal */
+  extractParamListEntries(typeLiteral, typeName) {
+    const entries = /* @__PURE__ */ new Map();
+    for (const member of typeLiteral.members) {
+      if (member.type === "TSPropertySignature" && member.key) {
+        const keyName = member.key.type === "Identifier" ? member.key.name : null;
+        if (keyName && member.typeAnnotation) {
+          const params = this.extractParamsFromType(
+            member.typeAnnotation.typeAnnotation
+          );
+          entries.set(keyName, params);
+        }
+      }
+    }
+    return entries;
+  }
+  /** Extract param descriptors from a TypeScript type */
+  extractParamsFromType(typeAnnotation) {
+    const params = [];
+    if (typeAnnotation.type === "TSUndefinedKeyword" || typeAnnotation.type === "TSNullKeyword") {
+      return params;
+    }
+    if (typeAnnotation.type === "TSTypeLiteral") {
+      const typeLiteral = typeAnnotation;
+      for (const member of typeLiteral.members) {
+        if (member.type === "TSPropertySignature" && member.key) {
+          const keyName = member.key.type === "Identifier" ? member.key.name : null;
+          if (keyName) {
+            const typeStr = member.typeAnnotation ? this.typeToString(member.typeAnnotation.typeAnnotation) : "unknown";
+            const required = !member.optional;
+            params.push({
+              name: keyName,
+              type: typeStr,
+              required
+            });
+          }
+        }
+      }
+    }
+    return params;
+  }
+  /** Convert TypeScript type annotation to string */
+  typeToString(type) {
+    if (type.type === "TSStringKeyword") return "string";
+    if (type.type === "TSNumberKeyword") return "number";
+    if (type.type === "TSBooleanKeyword") return "boolean";
+    if (type.type === "TSUndefinedKeyword") return "undefined";
+    if (type.type === "TSNullKeyword") return "null";
+    if (type.type === "TSUnionType") {
+      return type.types.map((t8) => this.typeToString(t8)).join(" | ");
+    }
+    if (type.type === "TSTypeLiteral") {
+      return "object";
+    }
+    if (type.type === "TSTypeReference" && type.typeName) {
+      const name = type.typeName;
+      return name.type === "Identifier" ? name.name : "unknown";
+    }
+    return "unknown";
+  }
+  /** Infer navigator type from type name */
+  inferTypeFromName(typeName) {
+    if (/stack/i.test(typeName)) return { type: "stack" };
+    if (/tab/i.test(typeName)) return { type: "tab" };
+    if (/drawer/i.test(typeName)) return { type: "drawer" };
+    return null;
+  }
+  /** Attach parsed type params to navigator screens */
+  attachParamsToNavigators(navigators, types) {
+    for (const navigator of navigators) {
+      const matchingType = types.find((t8) => t8.type === navigator.type);
+      if (matchingType) {
+        for (const screen of navigator.screens) {
+          const screenParams = matchingType.paramEntries.get(screen.name);
+          if (screenParams) {
+            screen.params = screenParams;
+          }
+        }
+      }
+    }
+  }
+  /** Build the complete navigation graph */
+  buildNavigationGraph(parsedNavigators) {
+    const screens = {};
+    const navigators = [];
+    let initialScreen = "";
+    for (const navigator of parsedNavigators) {
+      const screenNames = navigator.screens.map((s) => s.name);
+      navigators.push({
+        name: navigator.name,
+        type: navigator.type,
+        screens: screenNames,
+        parentNavigator: navigator.parentNavigator
+      });
+      if (!initialScreen && navigator.initialRouteName && (navigator.name.includes("Root") || screenNames.some((s) => s === "Auth" || s === "Main"))) {
+        initialScreen = navigator.initialRouteName;
+      }
+    }
+    for (const navigator of parsedNavigators) {
+      for (const screen of navigator.screens) {
+        const screenKey = screen.name;
+        const reachableTo = [];
+        const reachableFrom = [];
+        for (const otherScreen of navigator.screens) {
+          if (otherScreen.name !== screen.name) {
+            if (navigator.type === "tab") {
+              reachableTo.push(otherScreen.name);
+              reachableFrom.push(otherScreen.name);
+            } else {
+              reachableTo.push(otherScreen.name);
+            }
+          }
+        }
+        screens[screenKey] = {
+          screenName: screen.name,
+          navigatorType: navigator.type,
+          parentNavigator: navigator.name,
+          reachableFrom,
+          reachableTo,
+          params: screen.params
+        };
+      }
+    }
+    if (!initialScreen && parsedNavigators.length > 0) {
+      const firstNavigator = parsedNavigators[0];
+      const rootNavigator = parsedNavigators.find(
+        (n) => n.name.includes("Root") || firstNavigator && n.name === firstNavigator.name
+      );
+      if (rootNavigator && rootNavigator.screens && rootNavigator.screens.length > 0) {
+        const firstScreen = rootNavigator.screens[0];
+        initialScreen = firstScreen?.name || "";
+      }
+    }
+    return {
+      screens,
+      initialScreen,
+      navigators
+    };
+  }
+};
+
+// src/analyzers/ComponentAnalyzer.ts
+var import_fs5 = require("fs");
+var parser2 = __toESM(require("@babel/parser"));
+var import_traverse6 = __toESM(require("@babel/traverse"));
+var t6 = __toESM(require("@babel/types"));
+var ComponentAnalyzer = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Analyze components in a file */
+  async analyzeFile(filePath) {
+    try {
+      const code = (0, import_fs5.readFileSync)(filePath, "utf-8");
+      const ast = parser2.parse(code, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript", ["decorators", { decoratorsBeforeExport: true }]]
+      });
+      const components = [];
+      (0, import_traverse6.default)(ast, {
+        JSXElement: (path5) => {
+          const component = this.extractComponentFromJSXElement(path5.node);
+          if (component) {
+            components.push(component);
+          }
+        }
+      });
+      return components;
+    } catch (error2) {
+      console.error(`Failed to analyze file ${filePath}:`, error2);
+      return [];
+    }
+  }
+  extractComponentFromJSXElement(element) {
+    const elementName = this.getElementName(element.openingElement);
+    if (!elementName) return null;
+    const type = this.determineComponentType(elementName);
+    const props = this.extractProps(element.openingElement);
+    const { testID, accessibilityLabel } = this.extractAccessibilityProps(element.openingElement);
+    const children = this.extractChildren(element.children);
+    return {
+      name: elementName,
+      type,
+      props: Object.keys(props).length > 0 ? props : void 0,
+      children: children.length > 0 ? children : void 0,
+      testID,
+      accessibilityLabel
+    };
+  }
+  getElementName(openingElement) {
+    if (t6.isJSXIdentifier(openingElement.name)) {
+      return openingElement.name.name;
+    }
+    if (t6.isJSXMemberExpression(openingElement.name)) {
+      const parts = [];
+      let current = openingElement.name;
+      while (t6.isJSXMemberExpression(current)) {
+        if (t6.isJSXIdentifier(current.property)) {
+          parts.unshift(current.property.name);
+        }
+        current = current.object;
+      }
+      if (t6.isJSXIdentifier(current)) {
+        parts.unshift(current.name);
+      }
+      return parts.join(".");
+    }
+    return null;
+  }
+  determineComponentType(name) {
+    const viewComponents = ["View", "ScrollView", "SafeAreaView", "KeyboardAvoidingView"];
+    const inputComponents = ["TextInput", "Input"];
+    const buttonComponents = ["TouchableOpacity", "Pressable", "Button"];
+    const listComponents = ["FlatList", "SectionList"];
+    const modalComponents = ["Modal", "BottomSheet"];
+    if (viewComponents.includes(name)) return "view";
+    if (inputComponents.includes(name)) return "input";
+    if (buttonComponents.includes(name)) return "button";
+    if (listComponents.includes(name)) return "list";
+    if (modalComponents.includes(name)) return "modal";
+    return "custom";
+  }
+  extractProps(openingElement) {
+    const props = {};
+    for (const attr of openingElement.attributes) {
+      if (t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name)) {
+        const propName = attr.name.name;
+        if (attr.value === null) {
+          props[propName] = "true";
+        } else if (t6.isStringLiteral(attr.value)) {
+          props[propName] = attr.value.value;
+        } else if (t6.isJSXExpressionContainer(attr.value) && t6.isStringLiteral(attr.value.expression)) {
+          props[propName] = attr.value.expression.value;
+        }
+      }
+    }
+    return props;
+  }
+  extractAccessibilityProps(openingElement) {
+    const result = {};
+    for (const attr of openingElement.attributes) {
+      if (t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name)) {
+        const propName = attr.name.name;
+        if ((propName === "testID" || propName === "accessibilityLabel") && attr.value) {
+          if (t6.isStringLiteral(attr.value)) {
+            result[propName] = attr.value.value;
+          } else if (t6.isJSXExpressionContainer(attr.value) && t6.isStringLiteral(attr.value.expression)) {
+            result[propName] = attr.value.expression.value;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  extractChildren(children, depth = 0, maxDepth = 3) {
+    if (depth >= maxDepth) return [];
+    const extracted = [];
+    for (const child of children) {
+      if (t6.isJSXElement(child)) {
+        const component = this.extractComponentFromJSXElement(child);
+        if (component) {
+          extracted.push(component);
+        }
+      }
+    }
+    return extracted;
+  }
+};
+
+// src/analyzers/FormAnalyzer.ts
+var import_fs6 = require("fs");
+var parser3 = __toESM(require("@babel/parser"));
+var import_traverse7 = __toESM(require("@babel/traverse"));
+var t7 = __toESM(require("@babel/types"));
+var path3 = __toESM(require("path"));
+var FormAnalyzer = class {
+  config;
+  stateVariables = /* @__PURE__ */ new Map();
+  inputElements = [];
+  submitButtons = [];
+  constructor(config) {
+    this.config = config;
+  }
+  /** Analyze forms in a file */
+  async analyzeFile(filePath) {
+    try {
+      const code = (0, import_fs6.readFileSync)(filePath, "utf-8");
+      const ast = parser3.parse(code, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript", ["decorators", { decoratorsBeforeExport: true }]]
+      });
+      this.stateVariables.clear();
+      this.inputElements = [];
+      this.submitButtons = [];
+      (0, import_traverse7.default)(ast, {
+        CallExpression: (path5) => {
+          this.extractStateVariables(path5.node);
+        }
+      });
+      (0, import_traverse7.default)(ast, {
+        JSXElement: (path5) => {
+          this.extractFormElements(path5.node);
+        }
+      });
+      const validationRules = this.extractValidationRules(ast);
+      return this.buildForms(filePath, validationRules);
+    } catch (error2) {
+      console.error(`Failed to analyze forms in file ${filePath}:`, error2);
+      return [];
+    }
+  }
+  extractStateVariables(node) {
+    if (t7.isIdentifier(node.callee) && node.callee.name === "useState" && node.arguments.length > 0) {
+      return;
+    }
+  }
+  extractFormElements(element) {
+    const elementName = this.getElementName(element.openingElement);
+    if (!elementName) return;
+    if (elementName === "TextInput" || elementName === "Input") {
+      const inputInfo = this.extractInputInfo(element.openingElement);
+      this.inputElements.push(inputInfo);
+    }
+    if (["TouchableOpacity", "Pressable", "Button"].includes(elementName)) {
+      const buttonInfo = this.extractButtonInfo(element.openingElement);
+      if (buttonInfo) {
+        this.submitButtons.push(buttonInfo);
+      }
+    }
+  }
+  extractInputInfo(openingElement) {
+    const info2 = { varName: "" };
+    for (const attr of openingElement.attributes) {
+      if (t7.isJSXAttribute(attr) && t7.isJSXIdentifier(attr.name)) {
+        const propName = attr.name.name;
+        const propValue = this.extractAttributeValue(attr.value);
+        switch (propName) {
+          case "label":
+            info2.label = propValue;
+            break;
+          case "placeholder":
+            info2.placeholder = propValue;
+            break;
+          case "keyboardType":
+            info2.keyboardType = propValue;
+            break;
+          case "testID":
+            info2.testID = propValue;
+            break;
+          case "appilotsId":
+            info2.appilotsId = propValue;
+            if (propValue) info2.varName = propValue;
+            break;
+          case "value":
+            if (attr.value && t7.isJSXExpressionContainer(attr.value) && t7.isIdentifier(attr.value.expression)) {
+              info2.varName = attr.value.expression.name;
+            }
+            break;
+        }
+      }
+    }
+    return info2;
+  }
+  extractButtonInfo(openingElement) {
+    const info2 = {};
+    for (const attr of openingElement.attributes) {
+      if (t7.isJSXAttribute(attr) && t7.isJSXIdentifier(attr.name)) {
+        const propName = attr.name.name;
+        if (propName === "title" || propName === "label") {
+          info2.label = this.extractAttributeValue(attr.value);
+        }
+        if (propName === "onPress") {
+          if (attr.value && t7.isJSXExpressionContainer(attr.value)) {
+            if (t7.isIdentifier(attr.value.expression)) {
+              info2.handler = attr.value.expression.name;
+            } else if (t7.isArrowFunctionExpression(attr.value.expression) || t7.isFunctionExpression(attr.value.expression)) {
+              info2.handler = "anonymous";
+            }
+          }
+        }
+      }
+    }
+    return Object.keys(info2).length > 0 ? info2 : null;
+  }
+  extractAttributeValue(value) {
+    if (value === null) return void 0;
+    if (t7.isStringLiteral(value)) return value.value;
+    if (t7.isJSXExpressionContainer(value) && t7.isStringLiteral(value.expression)) {
+      return value.expression.value;
+    }
+    return void 0;
+  }
+  getElementName(openingElement) {
+    if (t7.isJSXIdentifier(openingElement.name)) {
+      return openingElement.name.name;
+    }
+    return null;
+  }
+  extractValidationRules(ast) {
+    const rules = {};
+    (0, import_traverse7.default)(ast, {
+      IfStatement: (path5) => {
+        const test = path5.node.test;
+        const rule = this.extractRuleFromCondition(test);
+        if (rule) {
+          const { field, description } = rule;
+          if (field && description) {
+            rules[field] = description;
+          }
+        }
+      }
+    });
+    return rules;
+  }
+  extractRuleFromCondition(test) {
+    let fieldName = "";
+    let description = "";
+    if (t7.isUnaryExpression(test) && test.operator === "!") {
+      if (t7.isCallExpression(test.argument)) {
+        const callExpr = test.argument;
+        if (t7.isMemberExpression(callExpr.callee)) {
+          const memberExpr = callExpr.callee;
+          if (t7.isIdentifier(memberExpr.object)) {
+            fieldName = memberExpr.object.name;
+            description = `${fieldName} is required`;
+          }
+        }
+      } else if (t7.isIdentifier(test.argument)) {
+        fieldName = test.argument.name;
+        description = `${fieldName} is required`;
+      }
+    }
+    if (t7.isBinaryExpression(test) && (test.operator === "<" || test.operator === "<=")) {
+      if (t7.isMemberExpression(test.left)) {
+        const memberExpr = test.left;
+        if (t7.isIdentifier(memberExpr.object)) {
+          fieldName = memberExpr.object.name;
+          if (t7.isNumericLiteral(test.right)) {
+            description = `${fieldName} must be at least ${test.right.value} characters`;
+          }
+        }
+      }
+    }
+    if (t7.isUnaryExpression(test) && test.operator === "!") {
+      if (t7.isCallExpression(test.argument) && t7.isMemberExpression(test.argument.callee)) {
+        const methodName = t7.isIdentifier(test.argument.callee.property) ? test.argument.callee.property.name : null;
+        if (methodName === "includes" && t7.isIdentifier(test.argument.callee.object)) {
+          fieldName = test.argument.callee.object.name;
+          description = `${fieldName} format is invalid`;
+        }
+      }
+    }
+    return fieldName && description ? { field: fieldName, description } : null;
+  }
+  buildForms(filePath, validationRules) {
+    if (this.inputElements.length === 0) return [];
+    const fileName = path3.basename(filePath, path3.extname(filePath));
+    const formId = `${fileName}Form`.replace(/Screen$/, "").toLowerCase();
+    const fields = this.inputElements.map((input) => {
+      const fieldType = this.inferFieldType(input);
+      const required = this.isFieldRequired(input.varName, validationRules);
+      return {
+        name: input.appilotsId || input.varName || input.testID || "field",
+        label: input.label,
+        type: fieldType,
+        required,
+        placeholder: input.placeholder
+      };
+    });
+    const lastButton = this.submitButtons[this.submitButtons.length - 1];
+    const submitAction = lastButton?.handler;
+    return [
+      {
+        id: formId,
+        fields,
+        submitAction,
+        validationRules: Object.keys(validationRules).length > 0 ? validationRules : void 0
+      }
+    ];
+  }
+  inferFieldType(input) {
+    const lowerVarName = input.varName.toLowerCase();
+    const lowerLabel = input.label?.toLowerCase() || "";
+    const lowerPlaceholder = input.placeholder?.toLowerCase() || "";
+    const combined = `${lowerVarName} ${lowerLabel} ${lowerPlaceholder}`;
+    if (input.keyboardType === "email-address" || input.keyboardType === "email") {
+      return "email";
+    }
+    if (input.keyboardType === "phone-pad" || input.keyboardType === "numeric") {
+      return input.keyboardType === "numeric" ? "number" : "phone";
+    }
+    if (combined.includes("email")) return "email";
+    if (combined.includes("phone") || combined.includes("tel")) return "phone";
+    if (combined.includes("password")) return "text";
+    if (combined.includes("number") || combined.includes("numeric")) return "number";
+    if (combined.includes("date")) return "date";
+    if (combined.includes("toggle") || combined.includes("check")) return "toggle";
+    if (combined.includes("select") || combined.includes("choice")) return "select";
+    return "text";
+  }
+  isFieldRequired(fieldName, rules) {
+    const rule = rules[fieldName];
+    return rule !== void 0 && rule.includes("required");
+  }
+};
+
+// src/pipeline/enrichment.ts
+function enrichScreenForAgent(screen) {
+  const targets = mergeTargets([
+    ...targetsFromForms(screen.forms),
+    ...targetsFromActions(screen.actions),
+    ...targetsFromCollections(screen.collections ?? [])
+  ]);
+  const flows = synthesizeFlows(screen, targets);
+  const agentHints = synthesizeAgentHints(screen, targets, flows);
+  return {
+    ...screen,
+    ...targets.length > 0 ? { targets } : {},
+    ...flows.length > 0 ? { flows } : {},
+    ...agentHints ? { agentHints } : {}
+  };
+}
+function targetsFromForms(forms) {
+  const targets = [];
+  for (const form of forms) {
+    for (const field of form.fields) {
+      targets.push({
+        id: field.locator?.id ?? field.name,
+        role: fieldToRole(field),
+        label: field.label,
+        fieldName: field.name,
+        locator: field.locator ?? { id: field.name, source: "inferred" },
+        sourceComponent: field.sourceComponent
+      });
+    }
+    if (form.submitAction && form.submitAction !== "anonymous") {
+      targets.push({
+        id: form.submitAction,
+        role: "submit",
+        actionId: form.submitAction,
+        label: form.submitAction
+      });
+    }
+  }
+  return targets;
+}
+function fieldToRole(field) {
+  if (field.type === "toggle") return "toggle";
+  if (field.type === "select") return "select";
+  if (field.type === "date") return "date";
+  return "input";
+}
+function targetsFromActions(actions) {
+  return actions.filter((action) => action.id).map((action) => ({
+    id: action.locator?.id ?? action.id,
+    role: action.type === "submit" ? "submit" : "button",
+    label: action.label,
+    locator: action.locator ?? { id: action.id, label: action.label, source: "inferred" },
+    actionId: action.id,
+    handler: action.handler,
+    targetScreen: action.targetScreen,
+    destructive: action.destructive,
+    requiresConfirmation: action.requiresConfirmation,
+    opensModal: action.opensModal,
+    opensBottomSheet: action.opensBottomSheet,
+    sourceComponent: action.sourceComponent
+  }));
+}
+function targetsFromCollections(collections) {
+  return collections.map((collection) => ({
+    id: collection.id,
+    role: "list",
+    label: collection.itemType ?? collection.dataSource ?? collection.id,
+    locator: { id: collection.id, testID: collection.id, source: "testID" },
+    sourceComponent: collection.component
+  }));
+}
+function mergeTargets(targets) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    if (!target.id) continue;
+    const existing = byId.get(target.id);
+    byId.set(target.id, existing ? { ...target, ...existing, locator: existing.locator ?? target.locator } : target);
+  }
+  return Array.from(byId.values()).sort((a, b) => a.id.localeCompare(b.id));
+}
+function synthesizeFlows(screen, targets) {
+  const flows = [];
+  for (const form of screen.forms) {
+    const submitAction = screen.actions.find((action) => action.id === form.submitAction) ?? screen.actions.find((action) => action.type === "submit");
+    if (!submitAction) continue;
+    flows.push({
+      id: `submit-${form.id}`,
+      title: submitAction.label ? `Submit ${submitAction.label}` : `Submit ${form.id}`,
+      intent: "form_submit",
+      steps: [
+        ...form.fields.map((field) => ({
+          type: field.type === "select" ? "select" : field.type === "toggle" ? "toggle" : "fill",
+          target: field.name,
+          label: field.label,
+          required: field.required,
+          description: field.placeholder
+        })),
+        { type: "press", target: submitAction.id, label: submitAction.label },
+        { type: "wait", description: describeWait(submitAction) }
+      ],
+      waitPolicy: waitPolicyForAction(submitAction),
+      safetyNotes: submitAction.requiresConfirmation || submitAction.destructive ? ["Requires confirmation before execution"] : void 0
+    });
+  }
+  for (const action of screen.actions) {
+    if (action.type === "submit") continue;
+    if (action.targetScreen) {
+      flows.push({
+        id: `navigate-${action.id}`,
+        title: action.label ? `Open ${action.label}` : `Navigate to ${action.targetScreen}`,
+        intent: "navigate",
+        steps: [{ type: "press", target: action.id, label: action.label }],
+        waitPolicy: waitPolicyForAction(action)
+      });
+    } else if (action.destructive || action.requiresConfirmation) {
+      flows.push({
+        id: `confirm-${action.id}`,
+        title: action.label ? `Confirm ${action.label}` : `Confirm ${action.id}`,
+        intent: "destructive_action",
+        steps: [
+          { type: "press", target: action.id, label: action.label },
+          { type: "confirm", description: "Wait for native or custom confirmation before continuing" },
+          { type: "wait", description: describeWait(action) }
+        ],
+        waitPolicy: waitPolicyForAction(action),
+        safetyNotes: ["Destructive or high-risk action"]
+      });
+    }
+  }
+  for (const collection of screen.collections ?? []) {
+    if (collection.rowAction || collection.rowActions && collection.rowActions.length > 0) {
+      flows.push({
+        id: `list-${collection.id}`,
+        title: `Act on an item in ${collection.id}`,
+        intent: "list_action",
+        steps: [
+          { type: "choose-list-item", target: collection.id, description: "Resolve the user reference to a visible or searchable row" },
+          { type: "press", description: collection.rowAction?.description ?? "Open the row action" }
+        ],
+        waitPolicy: { expectedOutcome: collection.rowAction?.targetScreen ? "navigation" : "inline-feedback" }
+      });
+    }
+  }
+  return flows.sort((a, b) => a.id.localeCompare(b.id));
+}
+function waitPolicyForAction(action) {
+  const expectedOutcome = action.successSignal?.type === "goBack" ? "goBack" : action.appilotsInferred?.expectedOutcome ?? (action.targetScreen ? "navigation" : void 0);
+  const signals = [action.successSignal, action.failureSignal].filter(Boolean);
+  return {
+    ...expectedOutcome ? { expectedOutcome } : {},
+    ...signals && signals.length > 0 ? { signals } : {},
+    ...action.appilotsInferred?.isAsyncTrigger ? { maxMs: 1e4 } : {}
+  };
+}
+function describeWait(action) {
+  if (action.successSignal?.description) return action.successSignal.description;
+  if (action.successSignal?.type === "goBack") return "Wait for the app to return to the previous screen";
+  if (action.targetScreen) return `Wait for navigation to ${action.targetScreen}`;
+  if (action.appilotsInferred?.expectedOutcome) return `Wait for ${action.appilotsInferred.expectedOutcome}`;
+  return "Wait for the UI to settle";
+}
+function synthesizeAgentHints(screen, targets, flows) {
+  const preferredTargets = targets.filter((target) => ["submit", "button", "list"].includes(target.role)).slice(0, 8).map((target) => target.id);
+  const commonTasks = flows.slice(0, 6).map((flow) => flow.title);
+  const safetyNotes = screen.actions.filter((action) => action.destructive || action.requiresConfirmation).map((action) => `${action.id} requires confirmation`);
+  const firstAsyncAction = screen.actions.find((action) => action.appilotsInferred?.isAsyncTrigger);
+  const hints = {
+    primaryGoal: synthesizePrimaryGoal(screen),
+    commonTasks,
+    preferredTargets,
+    ...firstAsyncAction ? { waitPolicy: waitPolicyForAction(firstAsyncAction) } : {},
+    ...safetyNotes.length > 0 ? { safetyNotes } : {}
+  };
+  return hints.primaryGoal || commonTasks.length > 0 || preferredTargets.length > 0 ? hints : void 0;
+}
+function synthesizePrimaryGoal(screen) {
+  const goals = [];
+  const collections = screen.collections ?? [];
+  if (collections.length > 0) {
+    const collectionNames = collections.map((collection) => collection.itemType ?? collection.dataSource ?? collection.id).filter(Boolean).slice(0, 3);
+    goals.push(
+      collectionNames.length > 0 ? `Browse and act on ${collectionNames.join(", ")} list data` : "Browse and act on list data"
+    );
+  }
+  const uniqueFields = /* @__PURE__ */ new Map();
+  for (const form of screen.forms) {
+    for (const field of form.fields) {
+      uniqueFields.set(field.name, field);
+    }
+  }
+  const fieldCount = uniqueFields.size;
+  if (fieldCount > 0) {
+    const requiredCount = Array.from(uniqueFields.values()).filter((field) => field.required).length;
+    const fieldLabel = fieldCount === 1 ? "field" : "fields";
+    goals.push(
+      requiredCount > 0 ? `Complete a form with ${fieldCount} ${fieldLabel} (${requiredCount} required)` : `Complete a form with ${fieldCount} ${fieldLabel}`
+    );
+  }
+  const navigationCount = screen.actions.filter((action) => action.targetScreen).length;
+  if (navigationCount > 0) {
+    goals.push(`Open ${navigationCount} related screen${navigationCount === 1 ? "" : "s"}`);
+  }
+  const submitCount = screen.actions.filter((action) => action.type === "submit").length;
+  if (submitCount > 0) {
+    goals.push(`Submit ${submitCount === 1 ? "the primary form" : `${submitCount} forms/actions`}`);
+  }
+  const asyncCount = screen.actions.filter((action) => action.appilotsInferred?.isAsyncTrigger).length;
+  if (asyncCount > 0) {
+    goals.push(`Wait for ${asyncCount === 1 ? "async feedback" : "async action feedback"}`);
+  }
+  if (goals.length > 0) return goals.join("; ");
+  if (screen.title) return `Screen labeled "${screen.title}"`;
+  return void 0;
+}
+
+// src/generators/MCPGenerator.ts
+var import_fast_glob3 = __toESM(require("fast-glob"));
+var MCPGenerator = class {
+  analyzerConfig;
+  options;
+  generatorConfig;
+  constructor(config) {
+    this.generatorConfig = config;
+    this.analyzerConfig = {
+      rootDir: config.rootDir,
+      include: config.include ?? ["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"],
+      exclude: config.exclude ?? ["**/node_modules/**", "**/__tests__/**", "**/dist/**"]
+    };
+    this.options = {
+      format: config.format ?? "json",
+      outputDir: config.outputDir ?? ".appilots",
+      includeSourcePaths: config.includeSourcePaths ?? false,
+      splitOutput: config.splitOutput ?? false,
+      version: config.version ?? "1.0"
+    };
+  }
+  /** Generate MCP documents from the project */
+  async generate() {
+    console.log("[MCPGenerator] Starting generation...");
+    const outputDir = this.options.outputDir || ".appilots";
+    await (0, import_promises2.mkdir)(outputDir, { recursive: true });
+    console.log(`[MCPGenerator] Output directory ensured: ${outputDir}`);
+    const screenAnalyzer = new ScreenAnalyzer(this.analyzerConfig, {
+      strictScreens: this.generatorConfig.strictScreens ?? true,
+      screenPatterns: this.generatorConfig.screenPatterns
+    });
+    const navigationAnalyzer = new NavigationAnalyzer(this.analyzerConfig, {
+      navigationInclude: this.generatorConfig.navigationInclude,
+      navigationExclude: this.generatorConfig.navigationExclude
+    });
+    const componentAnalyzer = new ComponentAnalyzer(this.analyzerConfig);
+    const formAnalyzer = new FormAnalyzer(this.analyzerConfig);
+    console.log("[MCPGenerator] Running analyzers...");
+    const [screens, navigation] = await Promise.all([
+      screenAnalyzer.analyze(),
+      navigationAnalyzer.analyze()
+    ]);
+    console.log(
+      `[MCPGenerator] Screen and navigation analysis complete. Found ${screens.length} screens`
+    );
+    const screenFiles = await (0, import_fast_glob3.default)(
+      this.analyzerConfig.include || ["**/*.tsx", "**/*.ts"],
+      {
+        cwd: this.analyzerConfig.rootDir,
+        ignore: this.analyzerConfig.exclude || ["**/node_modules/**"]
+      }
+    );
+    console.log(`[MCPGenerator] Analyzing components and forms from ${screenFiles.length} files...`);
+    const enrichmentPromises = screenFiles.map(async (file) => {
+      const filePath2 = import_node_path.default.resolve(this.analyzerConfig.rootDir, file);
+      try {
+        const [components, forms] = await Promise.all([
+          componentAnalyzer.analyzeFile(filePath2),
+          formAnalyzer.analyzeFile(filePath2)
+        ]);
+        return { filePath: filePath2, components, forms };
+      } catch (error2) {
+        console.warn(`[MCPGenerator] Failed to analyze ${file}:`, error2);
+        return { filePath: filePath2, components: [], forms: [] };
+      }
+    });
+    const enrichmentResults = await Promise.all(enrichmentPromises);
+    const enrichmentMap = /* @__PURE__ */ new Map();
+    for (const result of enrichmentResults) {
+      enrichmentMap.set(result.filePath, {
+        components: result.components,
+        forms: result.forms
+      });
+    }
+    const enrichedScreens = screens.map((screen) => {
+      const enrichment = enrichmentMap.get(screen.filePath);
+      if (enrichment) {
+        const existingComponentNames = new Set(screen.components.map((c) => c.name));
+        const newComponents = enrichment.components.filter(
+          (c) => !existingComponentNames.has(c.name)
+        );
+        const mergedForms = screen.forms.map((form) => ({
+          ...form,
+          fields: [...form.fields]
+        }));
+        for (const newForm of enrichment.forms) {
+          const existingForm = mergedForms.find((form) => form.id === newForm.id) ?? this.findFormWithSharedFields(mergedForms, newForm);
+          if (existingForm) {
+            this.mergeForm(existingForm, newForm);
+          } else {
+            mergedForms.push({
+              ...newForm,
+              fields: [...newForm.fields],
+              submitAction: this.namedSubmitAction(newForm.submitAction)
+            });
+          }
+        }
+        return {
+          ...screen,
+          components: [...screen.components, ...newComponents],
+          forms: mergedForms
+        };
+      }
+      return screen;
+    });
+    const agentReadyScreens = enrichedScreens.map(enrichScreenForAgent);
+    const projectInfo = await this.getProjectInfo();
+    const projectName = projectInfo.name;
+    console.log(`[MCPGenerator] Project name: ${projectName}`);
+    const document = {
+      version: this.options.version,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectName,
+      screens: agentReadyScreens,
+      navigation,
+      metadata: {
+        generatorVersion: "0.1.0",
+        ...projectInfo.version ? { appVersion: projectInfo.version } : {},
+        totalScreens: agentReadyScreens.length,
+        totalForms: agentReadyScreens.reduce((acc, s) => acc + s.forms.length, 0),
+        totalActions: agentReadyScreens.reduce((acc, s) => acc + s.actions.length, 0),
+        analyzedFiles: screenFiles.length,
+        // §D: Only set when strict mode filters out screens
+        ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {}
+      }
+    };
+    const serialized = JSON.stringify(document, null, 2);
+    const checksum = this.calculateChecksum(serialized);
+    const filePath = import_node_path.default.resolve(
+      outputDir,
+      `mcp-document.${this.options.format}`
+    );
+    await (0, import_promises2.writeFile)(filePath, serialized, "utf-8");
+    console.log(`[MCPGenerator] Document written to: ${filePath}`);
+    const checksumFilePath = import_node_path.default.resolve(outputDir, ".appilots-checksum");
+    await (0, import_promises2.writeFile)(checksumFilePath, checksum, "utf-8");
+    console.log(`[MCPGenerator] Checksum written to: ${checksumFilePath}`);
+    console.log("[MCPGenerator] Generation complete!");
+    return {
+      document,
+      filePath,
+      format: this.options.format,
+      checksum
+    };
+  }
+  /**
+   * Read the previously stored checksum from disk.
+   * Returns null if no checksum file exists (first run).
+   *
+   * §4: This replaces the incomplete `hasChanged` static method.
+   * To detect actual changes, compare this value with `output.checksum`
+   * after calling `generate()`.
+   */
+  static async readPreviousChecksum(outputDir) {
+    const checksumFilePath = import_node_path.default.resolve(outputDir, ".appilots-checksum");
+    try {
+      const content = await (0, import_promises2.readFile)(checksumFilePath, "utf-8");
+      return content.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Calculate SHA-256 checksum of content
+   */
+  calculateChecksum(content) {
+    return (0, import_node_crypto.createHash)("sha256").update(content).digest("hex");
+  }
+  mergeForm(target, source) {
+    for (const field of source.fields) {
+      const existingField = this.findEquivalentField(target.fields, field);
+      if (existingField) {
+        this.mergeField(existingField, field);
+      } else {
+        target.fields.push(field);
+      }
+    }
+    target.submitAction = target.submitAction ?? this.namedSubmitAction(source.submitAction);
+    target.validationRules = source.validationRules ? { ...source.validationRules, ...target.validationRules ?? {} } : target.validationRules;
+  }
+  findEquivalentField(fields, incoming) {
+    return fields.find((field) => {
+      if (field.name && incoming.name && field.name === incoming.name) return true;
+      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding) return true;
+      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id) return true;
+      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder) return true;
+      if (field.locator?.accessibilityLabel && incoming.locator?.accessibilityLabel && field.locator.accessibilityLabel === incoming.locator.accessibilityLabel) {
+        return true;
+      }
+      return false;
+    });
+  }
+  mergeField(target, source) {
+    if (this.isWeakInferredFieldName(target.name) && !this.isWeakInferredFieldName(source.name)) {
+      target.name = source.name;
+    }
+    target.label = target.label ?? source.label;
+    target.placeholder = target.placeholder ?? source.placeholder;
+    target.options = target.options ?? source.options;
+    target.locator = target.locator ?? source.locator;
+    target.sourceComponent = target.sourceComponent ?? source.sourceComponent;
+    target.valueBinding = target.valueBinding ?? source.valueBinding;
+    target.errorBinding = target.errorBinding ?? source.errorBinding;
+    target.required = target.required || source.required;
+    if (target.type === "text" && source.type !== "text") {
+      target.type = source.type;
+    }
+  }
+  namedSubmitAction(submitAction) {
+    return submitAction && submitAction !== "anonymous" ? submitAction : void 0;
+  }
+  isWeakInferredFieldName(name) {
+    return /^(text|value|input|query|search|selected|checked)$/i.test(name);
+  }
+  findFormWithSharedFields(forms, incoming) {
+    if (incoming.fields.length === 0) return void 0;
+    let best;
+    for (const form of forms) {
+      const overlap = incoming.fields.filter((field) => this.findEquivalentField(form.fields, field)).length;
+      if (overlap > 0 && (!best || overlap > best.overlap)) {
+        best = { form, overlap };
+      }
+    }
+    return best?.form;
+  }
+  /**
+   * Get project name and version from package.json in rootDir
+   */
+  async getProjectInfo() {
+    try {
+      const packageJsonPath = import_node_path.default.resolve(this.analyzerConfig.rootDir, "package.json");
+      const packageJsonContent = await (0, import_promises2.readFile)(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageJsonContent);
+      return {
+        name: packageJson.name || "Unknown Project",
+        version: typeof packageJson.version === "string" ? packageJson.version : void 0
+      };
+    } catch (error2) {
+      console.warn("[MCPGenerator] Failed to read package.json, using default project name");
+      return { name: "Unknown Project" };
+    }
+  }
+};
+
+// src/pipeline/metadata-lint.ts
+var MUTATION_VERB_RE = /\b(delete|destroy|remove|discard|wipe|revoke|cancel|reset|clear|create|add|register|save|submit|update|edit|change|toggle|pay|send|confirm|subscribe|unsubscribe|renew|downgrade|upgrade|transfer)\w*/i;
+function isMutating(action) {
+  if (action.destructive || action.effect === "destructive") {
+    return { mutating: true, reason: "flagged destructive" };
+  }
+  if (action.type === "submit" || action.type === "state_change") {
+    return { mutating: true, reason: `type "${action.type}"` };
+  }
+  const haystack = `${action.id} ${action.label ?? ""} ${action.handler ?? ""}`;
+  if ((action.type === "api_call" || action.type === "custom") && MUTATION_VERB_RE.test(haystack)) {
+    return { mutating: true, reason: "mutation verb in id/label/handler" };
+  }
+  return { mutating: false, reason: "" };
+}
+function lintActionMetadata(document) {
+  const warnings = [];
+  for (const screen of document.screens) {
+    for (const action of screen.actions ?? []) {
+      const { mutating, reason } = isMutating(action);
+      if (!mutating) continue;
+      const missing = [];
+      if (!action.effect) missing.push("effect");
+      if (!action.riskLevel) missing.push("riskLevel");
+      if (missing.length === 0) continue;
+      warnings.push({
+        screen: screen.name,
+        actionId: action.id,
+        actionType: action.type,
+        missing,
+        reason
+      });
+    }
+  }
+  return warnings;
+}
+function formatMetadataWarnings(warnings) {
+  return warnings.map(
+    (w) => `${w.screen}.${w.actionId} (${w.actionType}, ${w.reason}): missing ${w.missing.join(", ")}`
+  );
+}
+
+// src/cli/utils/metadata-report.ts
+function reportMetadataLint(document, strict) {
+  const warnings = lintActionMetadata(document);
+  if (warnings.length === 0) {
+    success("Metadata lint: all mutating actions declare effect + riskLevel");
+    return;
+  }
+  warn(`Metadata lint: ${warnings.length} mutating action(s) missing effect/riskLevel`);
+  for (const line of formatMetadataWarnings(warnings)) {
+    dim(`  ${line}`);
+  }
+  dim('  Declare them in registerScreen(): actions: [{ id, effect: "write" | "destructive", riskLevel: "low" | "medium" | "high" }]');
+  if (strict) {
+    error("--strict-metadata: failing due to missing action metadata");
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/sync.ts
+function syncCommand() {
+  return new import_commander2.Command("sync").description("Analyze project and sync MCP documents with Appilots").option("--verbose", "Enable verbose logging", false).option("--force", "Force upload even if nothing changed", false).option("--api-key <key>", "Appilots API key (overrides .appilotsrc and APPILOTS_API_KEY)").option("--project-id <id>", "Project ID (overrides .appilotsrc and APPILOTS_PROJECT_ID)").option("--server <url>", "Appilots server URL (overrides .appilotsrc and APPILOTS_SERVER_URL)").option("--json", "Output a machine-readable JSON result (implies --quiet)", false).option("--quiet", "Suppress banner and informational output", false).option("--strict-metadata", "Fail when mutating actions are missing effect/riskLevel metadata", false).action(async (options) => {
+    if (options.json) setLogMode("json");
+    else if (options.quiet) setLogMode("quiet");
+    try {
+      banner();
+      const loaded = loadConfig();
+      const apiKey = options.apiKey || loaded?.apiKey;
+      if (!apiKey) {
+        error("No .appilotsrc configuration found");
+        info("Run: appilots init --api-key <your-key>");
+        info("Or set APPILOTS_API_KEY, or pass --api-key");
+        jsonOutput({ success: false, error: "No configuration found (missing API key)" });
+        process.exit(1);
+        return;
+      }
+      const config = {
+        serverUrl: "http://localhost:4000",
+        outputDir: ".appilots",
+        ...loaded,
+        apiKey,
+        ...options.projectId ? { projectId: options.projectId } : {},
+        ...options.server ? { serverUrl: options.server } : {}
+      };
+      const apiClient = new AppilotsAPIClient({
+        serverUrl: config.serverUrl,
+        apiKey: config.apiKey
+      });
+      const outputDir = config.outputDir || ".appilots";
+      let previousChecksum = "";
+      try {
+        const checksumPath = (0, import_node_path2.join)(outputDir, ".appilots-checksum");
+        previousChecksum = (await (0, import_promises3.readFile)(checksumPath, "utf-8")).trim();
+      } catch {
+      }
+      let spinner = createSpinner("Analyzing project...");
+      spinner.start();
+      const generator = new MCPGenerator({
+        rootDir: process.cwd(),
+        outputDir,
+        format: "json",
+        strictScreens: config.strictScreens,
+        screenPatterns: config.screenPatterns,
+        include: config.include,
+        exclude: config.exclude,
+        navigationInclude: config.navigationInclude,
+        navigationExclude: config.navigationExclude
+      });
+      const output = await generator.generate();
+      spinner.stop();
+      success(
+        `Found ${output.document.metadata.totalScreens} screens, ${output.document.metadata.totalForms} forms, ${output.document.metadata.totalActions} actions`
+      );
+      reportMetadataLint(output.document, Boolean(options.strictMetadata));
+      if (!options.force && previousChecksum && previousChecksum === output.checksum) {
+        spinner = createSpinner("Checking remote status...");
+        spinner.start();
+        const status = await apiClient.status();
+        spinner.stop();
+        if (status.error) {
+          warn(`Could not verify remote: ${status.error}`);
+          info("Uploading anyway...");
+        } else if (status.activeMcp) {
+          success("Already up to date (no local or remote changes)");
+          jsonOutput({ success: true, unchanged: true, checksum: output.checksum });
+          return;
+        }
+      }
+      spinner = createSpinner("Uploading to Appilots...");
+      spinner.start();
+      const syncResult = await apiClient.sync(
+        output.document,
+        output.document.version,
+        output.document.metadata.appVersion
+      );
+      spinner.stop();
+      if (!syncResult.success) {
+        error(`Sync failed: ${syncResult.error}`);
+        jsonOutput({ success: false, error: syncResult.error });
+        process.exit(1);
+      }
+      if (syncResult.unchanged && !options.force) {
+        success("Already up to date on server");
+      } else {
+        success("Successfully synced MCP document");
+        info(`Document ID: ${syncResult.id}`);
+        info(`Checksum: ${syncResult.checksum}`);
+        if (config.projectId) {
+          const dashboardUrl = `${config.serverUrl}/dashboard/projects/${config.projectId}`;
+          info(`View on dashboard: ${dashboardUrl}`);
+        }
+      }
+      if (options.verbose) {
+        heading("\nSync Details:");
+        table([
+          ["Screens", String(syncResult.screensCount || 0)],
+          ["Forms", String(syncResult.formsCount || 0)],
+          ["Actions", String(syncResult.actionsCount || 0)],
+          ["Document ID", syncResult.id || "N/A"],
+          ["Previous checksum", previousChecksum || "(first run)"],
+          ["New checksum", output.checksum],
+          ["Changed", String(previousChecksum !== output.checksum)]
+        ]);
+      }
+      jsonOutput({
+        success: true,
+        unchanged: Boolean(syncResult.unchanged),
+        id: syncResult.id,
+        checksum: syncResult.checksum ?? output.checksum,
+        screensCount: syncResult.screensCount ?? output.document.metadata.totalScreens,
+        formsCount: syncResult.formsCount ?? output.document.metadata.totalForms,
+        actionsCount: syncResult.actionsCount ?? output.document.metadata.totalActions
+      });
+    } catch (err) {
+      error(`Sync failed: ${err instanceof Error ? err.message : String(err)}`);
+      jsonOutput({ success: false, error: err instanceof Error ? err.message : String(err) });
+      if (options.verbose) {
+        console.error(err);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/watch.ts
+var import_commander3 = require("commander");
+var import_node_fs = require("fs");
+function watchCommand() {
+  return new import_commander3.Command("watch").description("Watch project for changes and auto-sync MCP documents").option("--verbose", "Enable verbose logging", false).action(async (options) => {
+    try {
+      banner();
+      const config = loadConfig();
+      if (!config) {
+        error("No .appilotsrc configuration found");
+        info("Run: appilots init --api-key <your-key>");
+        process.exit(1);
+      }
+      const apiClient = new AppilotsAPIClient({
+        serverUrl: config.serverUrl,
+        apiKey: config.apiKey
+      });
+      info("Performing initial sync...");
+      const generatorConfig = {
+        rootDir: process.cwd(),
+        outputDir: config.outputDir || ".appilots",
+        format: "json",
+        strictScreens: config.strictScreens,
+        screenPatterns: config.screenPatterns,
+        include: config.include,
+        exclude: config.exclude,
+        navigationInclude: config.navigationInclude,
+        navigationExclude: config.navigationExclude
+      };
+      const generator = new MCPGenerator(generatorConfig);
+      const initialOutput = await generator.generate();
+      const initialSync = await apiClient.sync(initialOutput.document, initialOutput.document.version);
+      if (!initialSync.success) {
+        error(`Initial sync failed: ${initialSync.error}`);
+        process.exit(1);
+      }
+      success("Initial sync completed");
+      info(`Watching for changes in ${config.outputDir || ".appilots"}...`);
+      dim("Press Ctrl+C to stop\n");
+      let debounceTimer = null;
+      const DEBOUNCE_MS = 500;
+      const watcher = (0, import_node_fs.watch)(
+        process.cwd(),
+        { recursive: true },
+        async (eventType, filename) => {
+          if (!filename) return;
+          if (filename.startsWith(".") || filename.includes("node_modules") || filename.includes(config.outputDir || ".appilots")) {
+            return;
+          }
+          if (debounceTimer) {
+            clearTimeout(debounceTimer);
+          }
+          debounceTimer = setTimeout(async () => {
+            try {
+              if (options.verbose) {
+                info(`Change detected: ${filename}`);
+              }
+              const spinner = createSpinner("Re-analyzing project...");
+              spinner.start();
+              const newGenerator = new MCPGenerator(generatorConfig);
+              const output = await newGenerator.generate();
+              spinner.text = "Uploading changes...";
+              const syncResult = await apiClient.sync(output.document, output.document.version);
+              spinner.stop();
+              if (!syncResult.success) {
+                error(`Sync failed: ${syncResult.error}`);
+              } else if (syncResult.unchanged) {
+                info("Changes synced (no content changes detected)");
+              } else {
+                success("Changes synced successfully");
+                info(
+                  `${output.document.metadata.totalScreens} screens, ${output.document.metadata.totalForms} forms, ${output.document.metadata.totalActions} actions`
+                );
+              }
+            } catch (err) {
+              error(`Watch sync failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }, DEBOUNCE_MS);
+        }
+      );
+      process.on("SIGINT", () => {
+        info("Stopping watcher...");
+        watcher.close();
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+        process.exit(0);
+      });
+    } catch (err) {
+      error(`Watch failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/generate.ts
+var import_commander4 = require("commander");
+function generateCommand() {
+  return new import_commander4.Command("generate").description("Generate MCP documents from project source (local only)").option("-o, --output <path>", "Output directory for MCP documents", ".appilots").option("-f, --format <format>", "Output format (only json supported)", "json").option("--strict-metadata", "Fail when mutating actions are missing effect/riskLevel metadata", false).action(async (options) => {
+    try {
+      banner();
+      if (options.format && options.format !== "json") {
+        error(`Format "${options.format}" is not supported yet. Only "json" is available.`);
+        process.exit(1);
+      }
+      const spinner = createSpinner("Analyzing project...");
+      spinner.start();
+      const generator = new MCPGenerator({
+        rootDir: process.cwd(),
+        outputDir: options.output || ".appilots",
+        format: "json"
+      });
+      const output = await generator.generate();
+      spinner.stop();
+      success(
+        `Generated MCP document with ${output.document.metadata.totalScreens} screens, ${output.document.metadata.totalForms} forms, ${output.document.metadata.totalActions} actions`
+      );
+      info(`Written to: ${output.filePath}`);
+      info(`Checksum: ${output.checksum}`);
+      reportMetadataLint(output.document, Boolean(options.strictMetadata));
+    } catch (err) {
+      error(`Generation failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/status.ts
+var import_commander5 = require("commander");
+function statusCommand() {
+  return new import_commander5.Command("status").description("Show current project and MCP document status").option("--json", "Output a machine-readable JSON result (implies --quiet)", false).option("--quiet", "Suppress banner and informational output", false).action(async (options) => {
+    if (options.json) setLogMode("json");
+    else if (options.quiet) setLogMode("quiet");
+    try {
+      banner();
+      const config = loadConfig();
+      if (!config) {
+        error("No .appilotsrc configuration found");
+        info("Run: appilots init --api-key <your-key>");
+        jsonOutput({ success: false, error: "No .appilotsrc configuration found" });
+        process.exit(1);
+        return;
+      }
+      const apiClient = new AppilotsAPIClient({
+        serverUrl: config.serverUrl,
+        apiKey: config.apiKey
+      });
+      const status = await apiClient.status();
+      if (status.error) {
+        error(`Failed to fetch status: ${status.error}`);
+        jsonOutput({ success: false, error: status.error });
+        process.exit(1);
+      }
+      heading("\n\u{1F4CB} Local Configuration:");
+      table([
+        ["API Server", config.serverUrl],
+        ["Project ID", config.projectId || "(resolved from API key)"],
+        ["Output Directory", config.outputDir || ".appilots"],
+        ["Auto Activate", String(config.autoActivate ?? true)]
+      ]);
+      if (status.project) {
+        heading("\n\u{1F4CC} Project Info:");
+        table([["Name", status.project.name], ["ID", status.project.id]]);
+      }
+      if (status.activeMcp) {
+        heading("\n\u2705 Active MCP Document:");
+        table([
+          ["Document ID", status.activeMcp.id],
+          ["Version", status.activeMcp.version],
+          ["Screens", String(status.activeMcp.screensCount)],
+          ["Forms", String(status.activeMcp.formsCount)],
+          ["Actions", String(status.activeMcp.actionsCount)]
+        ]);
+      } else {
+        heading("\n\u26A0\uFE0F  No active MCP document");
+        info("Run: appilots sync");
+      }
+      success("Status retrieved successfully");
+      jsonOutput({
+        success: true,
+        local: {
+          serverUrl: config.serverUrl,
+          projectId: config.projectId || null,
+          outputDir: config.outputDir || ".appilots"
+        },
+        project: status.project ?? null,
+        activeMcp: status.activeMcp ?? null
+      });
+    } catch (err) {
+      error(`Status check failed: ${err instanceof Error ? err.message : String(err)}`);
+      jsonOutput({ success: false, error: err instanceof Error ? err.message : String(err) });
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/eval.ts
+var import_commander6 = require("commander");
+var import_fs9 = require("fs");
+var import_path7 = require("path");
+
+// src/eval/scenario-loader.ts
+var import_fs7 = require("fs");
+var import_path5 = require("path");
+function validateScenarioShape(raw) {
+  if (!raw || typeof raw !== "object") return "scenario must be a JSON object";
+  const s = raw;
+  if (typeof s.name !== "string" || !s.name.trim()) {
+    return '"name" is required and must be a non-empty string';
+  }
+  if (typeof s.when !== "string" || !s.when.trim()) {
+    return '"when" is required and must be a non-empty string (the user prompt)';
+  }
+  if (!s.expect || typeof s.expect !== "object") {
+    return '"expect" is required and must be an object (see docs: Testing your agent between releases)';
+  }
+  return null;
+}
+function loadScenarios(dir) {
+  const scenarios = [];
+  const errors = [];
+  let files;
+  try {
+    files = (0, import_fs7.readdirSync)(dir).filter((f) => f.endsWith(".json")).sort();
+  } catch {
+    return { scenarios, errors };
+  }
+  for (const file of files) {
+    const full = (0, import_path5.join)(dir, file);
+    let raw;
+    try {
+      raw = JSON.parse((0, import_fs7.readFileSync)(full, "utf-8"));
+    } catch (err) {
+      errors.push({ file, error: `invalid JSON: ${err instanceof Error ? err.message : String(err)}` });
+      continue;
+    }
+    const shapeError = validateScenarioShape(raw);
+    if (shapeError) {
+      errors.push({ file, error: shapeError });
+      continue;
+    }
+    scenarios.push({ file, scenario: raw });
+  }
+  return { scenarios, errors };
+}
+
+// src/eval/matcher.ts
+function normalizeReply(text) {
+  return text.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
+}
+function partialMatch(expected, actual) {
+  if (!expected) return true;
+  if (!actual) return false;
+  for (const key of Object.keys(expected)) {
+    const exp = expected[key];
+    const act = actual[key];
+    if (key === "fields" && Array.isArray(exp) && Array.isArray(act)) {
+      for (const expField of exp) {
+        const fieldId = expField.fieldId;
+        const matched = act.find(
+          (f) => f.fieldId === fieldId
+        );
+        if (!matched) return false;
+        if (expField.value !== void 0 && matched.value !== expField.value) {
+          return false;
+        }
+      }
+      continue;
+    }
+    if (typeof exp === "object" && exp !== null && !Array.isArray(exp)) {
+      if (typeof act !== "object" || act === null) return false;
+      if (!partialMatch(exp, act)) {
+        return false;
+      }
+      continue;
+    }
+    if (exp !== act) return false;
+  }
+  return true;
+}
+function matchesOne(expected, actual) {
+  if (expected.type !== actual.type) return false;
+  return partialMatch(expected.payload, actual.payload);
+}
+function matchActions(expected, actual, reply = "") {
+  if (expected.anyOf && expected.anyOf.length > 0) {
+    const reasons = [];
+    for (const branch of expected.anyOf) {
+      const res = matchActions(branch, actual, reply);
+      if (res.ok) return res;
+      reasons.push(res.reason ?? "no reason");
+    }
+    return {
+      ok: false,
+      reason: `anyOf: no branch matched \u2014 ${reasons.map((r, i) => `[${i}] ${r}`).join(" \xB7 ")}`
+    };
+  }
+  if (expected.forbidActionTypes && expected.forbidActionTypes.length > 0) {
+    const forbidden = actual.find((a) => expected.forbidActionTypes.includes(a.type));
+    if (forbidden) {
+      return {
+        ok: false,
+        reason: `forbidActionTypes: action of type=${forbidden.type} was emitted`
+      };
+    }
+  }
+  if (expected.replyMustNotContain && expected.replyMustNotContain.length > 0) {
+    const hay = normalizeReply(reply);
+    const leaked = expected.replyMustNotContain.find(
+      (needle) => hay.includes(normalizeReply(needle))
+    );
+    if (leaked) {
+      return {
+        ok: false,
+        reason: `replyMustNotContain: "${leaked}" was echoed in the reply "${reply.slice(0, 120)}"`
+      };
+    }
+  }
+  if (expected.replyMustContain && expected.replyMustContain.length > 0) {
+    const hay = normalizeReply(reply);
+    const hit = expected.replyMustContain.some((needle) => hay.includes(normalizeReply(needle)));
+    if (!hit) {
+      return {
+        ok: false,
+        reason: `replyMustContain: none of [${expected.replyMustContain.join(", ")}] found in reply "${reply.slice(0, 120)}"`
+      };
+    }
+  }
+  const mode2 = expected.mode ?? "any";
+  const expectedActions = expected.actions ?? [];
+  if (mode2 === "none") {
+    if (actual.length === 0) return { ok: true };
+    return {
+      ok: false,
+      reason: `none mode: expected 0 actions, got ${actual.length} (${actual.map((a) => a.type).join(", ")})`
+    };
+  }
+  if (mode2 === "exact") {
+    if (actual.length !== expectedActions.length) {
+      return {
+        ok: false,
+        reason: `exact mode: expected ${expectedActions.length} action(s), got ${actual.length}`
+      };
+    }
+    for (let i = 0; i < expectedActions.length; i++) {
+      if (!matchesOne(expectedActions[i], actual[i])) {
+        return {
+          ok: false,
+          reason: `exact mode: action[${i}] mismatch \u2014 expected type=${expectedActions[i].type}, got type=${actual[i].type}`
+        };
+      }
+    }
+    return { ok: true };
+  }
+  if (mode2 === "first") {
+    const first = actual[0];
+    if (!first) {
+      return { ok: false, reason: "first mode: no actions emitted" };
+    }
+    if (!expectedActions[0] || !matchesOne(expectedActions[0], first)) {
+      return {
+        ok: false,
+        reason: `first mode: first action did not match \u2014 expected type=${expectedActions[0]?.type}, got type=${first.type}`
+      };
+    }
+    for (const exp of expectedActions.slice(1)) {
+      if (!actual.some((a) => matchesOne(exp, a))) {
+        return {
+          ok: false,
+          reason: `first mode: expected action of type=${exp.type} not found in remaining actions`
+        };
+      }
+    }
+    return { ok: true };
+  }
+  for (const exp of expectedActions) {
+    if (!actual.some((a) => matchesOne(exp, a))) {
+      return {
+        ok: false,
+        reason: `any mode: expected action of type=${exp.type} not found`
+      };
+    }
+  }
+  return { ok: true };
+}
+
+// src/eval/baseline.ts
+var import_fs8 = require("fs");
+var import_path6 = require("path");
+var EMPTY_BASELINE = { generatedAt: null, gitSha: null, perScenario: {} };
+function loadBaseline(path5) {
+  if (!(0, import_fs8.existsSync)(path5)) return { ...EMPTY_BASELINE, perScenario: {} };
+  try {
+    const raw = JSON.parse((0, import_fs8.readFileSync)(path5, "utf-8"));
+    return {
+      generatedAt: raw.generatedAt ?? null,
+      gitSha: raw.gitSha ?? null,
+      perScenario: raw.perScenario ?? {}
+    };
+  } catch {
+    return { ...EMPTY_BASELINE, perScenario: {} };
+  }
+}
+function saveBaseline(path5, baseline) {
+  (0, import_fs8.mkdirSync)((0, import_path6.dirname)(path5), { recursive: true });
+  (0, import_fs8.writeFileSync)(path5, `${JSON.stringify(baseline, null, 2)}
+`, "utf-8");
+}
+function buildBaseline(outcomes, meta) {
+  const perScenario = {};
+  for (const o of outcomes) {
+    perScenario[o.name] = {
+      status: o.status,
+      totalTokens: o.totalTokens,
+      ...o.failureReason ? { failureReason: o.failureReason } : {}
+    };
+  }
+  return { generatedAt: meta.generatedAt, gitSha: meta.gitSha ?? null, perScenario };
+}
+function diffAgainstBaseline(outcomes, baseline, maxTokenRegression) {
+  const regressions = [];
+  for (const outcome of outcomes) {
+    const prior = baseline.perScenario[outcome.name];
+    if (!prior) continue;
+    if (outcome.status === "failed" && prior.status === "passed") {
+      regressions.push({
+        name: outcome.name,
+        kind: "newly-failing",
+        detail: outcome.failureReason ?? "scenario now fails (previously passed)"
+      });
+      continue;
+    }
+    if (outcome.status === "passed" && prior.status === "passed" && prior.totalTokens > 0 && outcome.totalTokens > prior.totalTokens * (1 + maxTokenRegression)) {
+      const pct = Math.round((outcome.totalTokens - prior.totalTokens) / prior.totalTokens * 100);
+      regressions.push({
+        name: outcome.name,
+        kind: "token-regression",
+        detail: `tokens ${prior.totalTokens} \u2192 ${outcome.totalTokens} (+${pct}%, threshold +${Math.round(maxTokenRegression * 100)}%)`
+      });
+    }
+  }
+  return regressions;
+}
+
+// src/eval/scaffold.ts
+var EXAMPLE_SCENARIO = {
+  name: "agent-fills-signup-form",
+  description: "The agent should fill the visible signup form fields from a single spoken instruction. Edit `given.observation` to match a real screen in your app, and `when` to a prompt your users would actually say.",
+  given: {
+    screen: "SignupScreen",
+    observation: {
+      route: "SignupScreen",
+      texts: ["Create your account"],
+      inputs: [
+        { id: "email", label: "Email", required: true },
+        { id: "name", label: "Full name", required: true }
+      ],
+      buttons: [{ id: "btn-submit-signup", label: "Sign up" }]
+    }
+  },
+  when: "My name is Jane Doe and my email is jane@example.com",
+  expect: {
+    mode: "any",
+    actions: [
+      {
+        type: "form_fill",
+        payload: {
+          fields: [{ fieldId: "name" }, { fieldId: "email" }]
+        }
+      }
+    ]
+  }
+};
+
+// src/cli/commands/eval.ts
+var DEFAULT_MIN_PASS_RATE = 0.95;
+var DEFAULT_MAX_TOKEN_REGRESSION = 0.25;
+function parseRate(raw, fallback, flagName) {
+  if (raw === void 0) return fallback;
+  const n = Number(raw);
+  if (Number.isNaN(n)) {
+    warn(`Ignoring invalid ${flagName} value "${raw}" \u2014 using ${fallback}`);
+    return fallback;
+  }
+  return n;
+}
+function evalCommand() {
+  return new import_commander6.Command("eval").description(
+    "Run agent eval scenarios against the current MCP document in dry-run mode and check for regressions vs a committed baseline"
+  ).option("--init", "Scaffold an example scenario in the scenarios directory", false).option("--force", "With --init, overwrite an existing example scenario", false).option("--dir <path>", "Scenarios directory (default: <outputDir>/scenarios)").option("--baseline <path>", "Baseline file path (default: <outputDir>/eval-baseline.json)").option(
+    "--update-baseline",
+    "Record this run as the new baseline (refuses if pass rate is below the threshold)",
+    false
+  ).option("--min-pass-rate <n>", "Minimum fraction of scenarios that must pass, 0-1 (default: 0.95)").option(
+    "--max-token-regression <n>",
+    "Max fractional token increase before a passing scenario is flagged, e.g. 0.25 for +25% (default: 0.25)"
+  ).option("--model <id>", "Model override for scenarios that do not set their own modelOverride").option("--api-key <key>", "Appilots API key (overrides .appilotsrc and APPILOTS_API_KEY)").option("--project-id <id>", "Project ID (overrides .appilotsrc and APPILOTS_PROJECT_ID)").option("--server <url>", "Appilots server URL (overrides .appilotsrc and APPILOTS_SERVER_URL)").option("--json", "Output a machine-readable JSON result (implies --quiet)", false).option("--quiet", "Suppress banner and informational output", false).action(async (options) => {
+    if (options.json) setLogMode("json");
+    else if (options.quiet) setLogMode("quiet");
+    try {
+      banner();
+      const loaded = loadConfig();
+      const outputDir = loaded?.outputDir || ".appilots";
+      const scenariosDir = options.dir || loaded?.eval?.scenariosDir || (0, import_path7.join)(outputDir, "scenarios");
+      if (options.init) {
+        (0, import_fs9.mkdirSync)(scenariosDir, { recursive: true });
+        const examplePath = (0, import_path7.join)(scenariosDir, "example.json");
+        if ((0, import_fs9.existsSync)(examplePath) && !options.force) {
+          warn(`${examplePath} already exists \u2014 pass --force to overwrite`);
+        } else {
+          (0, import_fs9.writeFileSync)(examplePath, `${JSON.stringify(EXAMPLE_SCENARIO, null, 2)}
+`, "utf-8");
+          success(`Wrote example scenario to ${examplePath}`);
+        }
+        info("Edit it to match a real screen in your app, then:");
+        dim("  $ appilots eval --update-baseline   # capture the current (good) behavior");
+        dim("  $ appilots eval                     # check for regressions on future runs");
+        jsonOutput({ success: true, scenariosDir, examplePath });
+        return;
+      }
+      const apiKey = options.apiKey || loaded?.apiKey;
+      if (!apiKey) {
+        error("No .appilotsrc configuration found");
+        info("Run: appilots init --api-key <your-key>");
+        info("Or set APPILOTS_API_KEY, or pass --api-key");
+        jsonOutput({ success: false, error: "No configuration found (missing API key)" });
+        process.exit(1);
+        return;
+      }
+      const config = {
+        serverUrl: "http://localhost:4000",
+        ...loaded,
+        apiKey,
+        ...options.projectId ? { projectId: options.projectId } : {},
+        ...options.server ? { serverUrl: options.server } : {}
+      };
+      const baselinePath = options.baseline || loaded?.eval?.baselinePath || (0, import_path7.join)(outputDir, "eval-baseline.json");
+      const minPassRate = parseRate(
+        options.minPassRate,
+        loaded?.eval?.minPassRate ?? DEFAULT_MIN_PASS_RATE,
+        "--min-pass-rate"
+      );
+      const maxTokenRegression = parseRate(
+        options.maxTokenRegression,
+        loaded?.eval?.maxTokenRegression ?? DEFAULT_MAX_TOKEN_REGRESSION,
+        "--max-token-regression"
+      );
+      const loadedScenarios = loadScenarios(scenariosDir);
+      if (loadedScenarios.errors.length > 0) {
+        for (const scenarioError of loadedScenarios.errors) {
+          error(`${scenarioError.file}: ${scenarioError.error}`);
+        }
+        jsonOutput({
+          success: false,
+          error: "One or more scenario files failed to load",
+          details: loadedScenarios.errors
+        });
+        process.exit(1);
+        return;
+      }
+      if (loadedScenarios.scenarios.length === 0) {
+        error(`No scenarios found in ${scenariosDir}`);
+        info("Run: appilots eval --init");
+        jsonOutput({ success: false, error: `No scenarios found in ${scenariosDir}` });
+        process.exit(1);
+        return;
+      }
+      const nameCounts = /* @__PURE__ */ new Map();
+      for (const { scenario } of loadedScenarios.scenarios) {
+        nameCounts.set(scenario.name, (nameCounts.get(scenario.name) ?? 0) + 1);
+      }
+      const duplicates = [...nameCounts.entries()].filter(([, count]) => count > 1).map(([name]) => name);
+      if (duplicates.length > 0) {
+        error(
+          `Duplicate scenario name(s) \u2014 "name" must be unique across all scenario files: ${duplicates.join(", ")}`
+        );
+        jsonOutput({ success: false, error: `Duplicate scenario names: ${duplicates.join(", ")}` });
+        process.exit(1);
+        return;
+      }
+      const apiClient = new AppilotsAPIClient({ serverUrl: config.serverUrl, apiKey: config.apiKey });
+      const requests = loadedScenarios.scenarios.map(({ scenario }) => ({
+        id: scenario.name,
+        screen: scenario.given?.screen,
+        observation: scenario.given?.observation,
+        prompt: scenario.when,
+        modelOverride: scenario.modelOverride || options.model
+      }));
+      const spinner = createSpinner(`Running ${requests.length} scenario(s)...`);
+      spinner.start();
+      const runResult = await apiClient.evalRun(requests);
+      spinner.stop();
+      if (runResult.error) {
+        error(`Eval run failed: ${runResult.error}`);
+        jsonOutput({ success: false, error: runResult.error });
+        process.exit(1);
+        return;
+      }
+      const resultsById = new Map((runResult.results ?? []).map((r) => [r.id, r]));
+      const outcomes = loadedScenarios.scenarios.map(({ scenario }) => {
+        const result = resultsById.get(scenario.name);
+        if (!result) {
+          return {
+            name: scenario.name,
+            status: "failed",
+            totalTokens: 0,
+            failureReason: "no result returned by the API for this scenario"
+          };
+        }
+        const match = matchActions(scenario.expect, result.actions, result.content);
+        return {
+          name: scenario.name,
+          status: match.ok ? "passed" : "failed",
+          totalTokens: result.totalTokens,
+          failureReason: match.ok ? void 0 : match.reason
+        };
+      });
+      const passed = outcomes.filter((o) => o.status === "passed").length;
+      const total = outcomes.length;
+      const passRate = total > 0 ? passed / total : 1;
+      heading("\nResults:");
+      table(
+        outcomes.map((o) => [
+          o.status === "passed" ? `\u2713 ${o.name}` : `\u2717 ${o.name}`,
+          o.status === "passed" ? `${o.totalTokens} tokens` : o.failureReason || "failed"
+        ])
+      );
+      const baseline = loadBaseline(baselinePath);
+      let regressions = [];
+      if (!options.updateBaseline) {
+        regressions = diffAgainstBaseline(outcomes, baseline, maxTokenRegression);
+        if (regressions.length > 0) {
+          heading("\nRegressions vs baseline:");
+          table(regressions.map((r) => [r.name, `${r.kind}: ${r.detail}`]));
+        }
+      }
+      const passRatePct = Math.round(passRate * 1e3) / 10;
+      const minPassRatePct = Math.round(minPassRate * 1e3) / 10;
+      heading(`
+Pass rate: ${passed}/${total} (${passRatePct}%) \u2014 threshold ${minPassRatePct}%`);
+      if (options.updateBaseline) {
+        if (passRate < minPassRate) {
+          error(
+            `Refusing to update baseline: pass rate ${passRatePct}% is below the ${minPassRatePct}% threshold`
+          );
+          info("Fix the failing scenario(s) first, then re-run with --update-baseline.");
+          jsonOutput({ success: false, passRate, minPassRate, total, passed, results: outcomes });
+          process.exit(1);
+          return;
+        }
+        const newBaseline = buildBaseline(outcomes, {
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          gitSha: process.env.GIT_SHA ?? null
+        });
+        saveBaseline(baselinePath, newBaseline);
+        success(`Updated baseline at ${baselinePath}`);
+        jsonOutput({ success: true, passRate, minPassRate, total, passed, results: outcomes });
+        return;
+      }
+      const ok = passRate >= minPassRate && regressions.length === 0;
+      jsonOutput({
+        success: ok,
+        passRate,
+        minPassRate,
+        total,
+        passed,
+        failed: total - passed,
+        regressions,
+        results: outcomes
+      });
+      if (!ok) {
+        if (passRate < minPassRate) {
+          error(`Pass rate ${passRatePct}% is below the ${minPassRatePct}% threshold`);
+        }
+        if (regressions.length > 0) {
+          error(`${regressions.length} regression(s) vs baseline`);
+        }
+        process.exit(1);
+      } else {
+        success("Eval passed");
+      }
+    } catch (err) {
+      error(`Eval failed: ${err instanceof Error ? err.message : String(err)}`);
+      jsonOutput({ success: false, error: err instanceof Error ? err.message : String(err) });
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/index.ts
+async function main() {
+  const program = new import_commander7.Command();
+  program.name("appilots").description(
+    "Analyze your React Native app and generate MCP documents for AI-powered navigation.\n\nQuick start:\n  $ appilots init --api-key ak_xxx\n  $ appilots sync\n  $ appilots watch"
+  ).version("0.1.0").option("--verbose", "Enable verbose logging");
+  program.addCommand(initCommand());
+  program.addCommand(syncCommand());
+  program.addCommand(watchCommand());
+  program.addCommand(generateCommand());
+  program.addCommand(statusCommand());
+  program.addCommand(evalCommand());
+  const args = process.argv.slice(2);
+  const firstArg = args[0];
+  const hasCommand = firstArg !== void 0 && args.length > 0 && !firstArg.startsWith("-");
+  if (args.length === 0) {
+    const config = loadConfig();
+    if (config) {
+      process.argv.push("sync");
+    } else {
+      banner();
+      info("Welcome to Appilots! Get started with:");
+      info("  appilots init --api-key <your-ak_key>");
+      console.log("");
+      program.outputHelp();
+      return;
+    }
+  }
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map