@appilots/cli 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3070 @@
+import fs, { mkdir, writeFile, readFile } from 'fs/promises';
+import * as path4 from 'path';
+import path4__default, { join, resolve } from 'path';
+import traverse4 from '@babel/traverse';
+import * as BabelTypes from '@babel/types';
+import glob from 'fast-glob';
+import * as parser from '@babel/parser';
+import { parse } from '@babel/parser';
+import { promises, readFileSync, writeFileSync, existsSync, statSync } from 'fs';
+import { createHash } from 'crypto';
+
+// src/analyzers/ScreenAnalyzer.ts
+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 parse(source, {
+    sourceType: "module",
+    plugins: [...DEFAULT_PARSER_PLUGINS, ...parserPlugins]
+  });
+}
+function findJsxAttribute(element, name) {
+  return element.attributes.find(
+    (attr) => BabelTypes.isJSXAttribute(attr) && BabelTypes.isJSXIdentifier(attr.name) && attr.name.name === name
+  );
+}
+function getStringAttr(element, name) {
+  const attr = findJsxAttribute(element, name);
+  if (!attr || !attr.value) return void 0;
+  if (BabelTypes.isStringLiteral(attr.value)) return attr.value.value;
+  if (BabelTypes.isJSXExpressionContainer(attr.value) && BabelTypes.isStringLiteral(attr.value.expression)) {
+    return attr.value.expression.value;
+  }
+  return void 0;
+}
+function getExpressionIdentifierAttr(element, name) {
+  const attr = findJsxAttribute(element, name);
+  if (!attr?.value || !BabelTypes.isJSXExpressionContainer(attr.value)) return void 0;
+  return BabelTypes.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";
+}
+function collectFunctions(ast) {
+  const handlers = /* @__PURE__ */ new Map();
+  traverse4(ast, {
+    FunctionDeclaration: (nodePath) => {
+      if (nodePath.node.id?.name) handlers.set(nodePath.node.id.name, nodePath.node);
+    },
+    VariableDeclarator: (nodePath) => {
+      if (!BabelTypes.isIdentifier(nodePath.node.id)) return;
+      const init = nodePath.node.init;
+      if (BabelTypes.isArrowFunctionExpression(init) || BabelTypes.isFunctionExpression(init)) {
+        handlers.set(nodePath.node.id.name, init);
+      }
+    }
+  });
+  return handlers;
+}
+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 (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;
+          successSignal = { type: "navigation", target: firstArg.value };
+        }
+      }
+      if (BabelTypes.isIdentifier(node.callee.object) && node.callee.object.name === "navigation" && method === "goBack") {
+        successSignal = { type: "goBack", description: "Action returns to the previous screen" };
+      }
+      if (BabelTypes.isIdentifier(node.callee.object) && node.callee.object.name === "Alert" && method === "alert") {
+        nativeConfirmationExpected = true;
+      }
+      if (BabelTypes.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 = BabelTypes.isStringLiteral(secondArg) ? secondArg.value : BabelTypes.isStringLiteral(firstArg) ? firstArg.value : void 0;
+        const signal = { type: "toast", description: text };
+        if (/(error|danger|fail)/i.test(method) || BabelTypes.isStringLiteral(firstArg) && /error/i.test(firstArg.value)) {
+          failureSignal = signal;
+        } else {
+          successSignal = successSignal ?? signal;
+        }
+      }
+    }
+    if (BabelTypes.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 && BabelTypes.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 (BabelTypes.isAwaitExpression(node)) hasAwait = true;
+    if (BabelTypes.isCallExpression(node)) inspectCall(node);
+    if (BabelTypes.isMemberExpression(node) && BabelTypes.isIdentifier(node.property) && DESTRUCTIVE_VERB.test(node.property.name)) {
+      destructive = true;
+    }
+  };
+  if (fn.body) {
+    traverse4(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);
+}
+function extractNavigationCalls(ast) {
+  const calls = [];
+  traverse4(ast, {
+    noScope: !BabelTypes.isFile(ast),
+    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)) {
+        return;
+      }
+      const method = node.callee.property.name;
+      if (!["navigate", "push", "replace", "goBack"].includes(method)) return;
+      const firstArg = node.arguments[0];
+      const targetScreen = BabelTypes.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 || !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;
+}
+
+// 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 glob(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 glob(this.screenPatterns, {
+        cwd: this.config.rootDir,
+        ignore: exclude
+      });
+      screenPatternFiles = new Set(matched.map((f) => path4__default.resolve(this.config.rootDir, f)));
+    }
+    const screens = [];
+    this.screensFilteredOut = 0;
+    for (const file of files) {
+      const filePath = path4__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 (error) {
+        if (this.verbose) {
+          console.warn(`[ScreenAnalyzer] Failed to parse ${file}:`, error instanceof Error ? error.message : error);
+        }
+      }
+    }
+    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 fs.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);
+    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;
+    traverse4(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;
+    traverse4(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 = "";
+    traverse4(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();
+    traverse4(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();
+    traverse4(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();
+    traverse4(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])
+    );
+    traverse4(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();
+    traverse4(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 info = analyzeFunctionBehavior(name, fn, handlers);
+      out.set(name, info);
+    }
+    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) {
+      traverse4(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 = [];
+    traverse4(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();
+    traverse4(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;
+    traverse4(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);
+    }
+    traverse4(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;
+    traverse4(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;
+        traverse4(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 = path4__default.basename(filePath);
+    return basename2.replace(/\.(tsx?|jsx?)$/, "");
+  }
+};
+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 promises.readFile(filePath, "utf-8");
+        const navigators = this.parseNavigators(content, filePath);
+        const types = this.parseParamTypes(content, filePath);
+        parsedNavigators.push(...navigators);
+        typeExports.push(...types);
+      } catch (error) {
+        console.warn(`Failed to parse ${filePath}:`, error);
+      }
+    }
+    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 glob(patterns, {
+      cwd: this.config.rootDir,
+      ignore: excludePatterns
+    });
+    return files.map((file) => 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();
+      traverse4(ast, {
+        // Detect createStackNavigator / createTabNavigator / createDrawerNavigator calls
+        CallExpression: (nodePath) => {
+          const { node } = nodePath;
+          const callee = node.callee;
+          let navigatorType = null;
+          if (BabelTypes.isIdentifier(callee) && callee.name === "createNativeStackNavigator") {
+            navigatorType = "stack";
+          } else if (BabelTypes.isIdentifier(callee) && callee.name === "createStackNavigator") {
+            navigatorType = "stack";
+          } else if (BabelTypes.isIdentifier(callee) && callee.name === "createBottomTabNavigator") {
+            navigatorType = "tab";
+          } else if (BabelTypes.isIdentifier(callee) && callee.name === "createTabNavigator") {
+            navigatorType = "tab";
+          } else if (BabelTypes.isIdentifier(callee) && callee.name === "createDrawerNavigator") {
+            navigatorType = "drawer";
+          }
+          if (navigatorType) {
+            const parent = nodePath.parent;
+            if (BabelTypes.isVariableDeclarator(parent) && BabelTypes.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 (BabelTypes.isJSXMemberExpression(openingElement.name) && BabelTypes.isJSXIdentifier(openingElement.name.object)) {
+            const objectName = openingElement.name.object.name;
+            const propertyName = BabelTypes.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) => BabelTypes.isJSXAttribute(attr) && BabelTypes.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
+                );
+                if (BabelTypes.isJSXAttribute(initialRouteAttr) && BabelTypes.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 (error) {
+      console.warn(`Failed to parse navigators in ${filePath}:`, error);
+    }
+    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 (BabelTypes.isJSXElement(child) && BabelTypes.isJSXMemberExpression(child.openingElement.name)) {
+        const memberExpr = child.openingElement.name;
+        if (BabelTypes.isJSXIdentifier(memberExpr.object) && memberExpr.object.name === navigatorVarName && BabelTypes.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) => BabelTypes.isJSXAttribute(a) && BabelTypes.isJSXIdentifier(a.name) && a.name.name === attrName
+    );
+    if (BabelTypes.isJSXAttribute(attr) && BabelTypes.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 || []
+        ]
+      });
+      traverse4(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 (error) {
+      console.warn(`Failed to parse types in ${filePath}:`, error);
+    }
+    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
+    };
+  }
+};
+var ComponentAnalyzer = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Analyze components in a file */
+  async analyzeFile(filePath) {
+    try {
+      const code = readFileSync(filePath, "utf-8");
+      const ast = parser.parse(code, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript", ["decorators", { decoratorsBeforeExport: true }]]
+      });
+      const components = [];
+      traverse4(ast, {
+        JSXElement: (path5) => {
+          const component = this.extractComponentFromJSXElement(path5.node);
+          if (component) {
+            components.push(component);
+          }
+        }
+      });
+      return components;
+    } catch (error) {
+      console.error(`Failed to analyze file ${filePath}:`, error);
+      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 (BabelTypes.isJSXIdentifier(openingElement.name)) {
+      return openingElement.name.name;
+    }
+    if (BabelTypes.isJSXMemberExpression(openingElement.name)) {
+      const parts = [];
+      let current = openingElement.name;
+      while (BabelTypes.isJSXMemberExpression(current)) {
+        if (BabelTypes.isJSXIdentifier(current.property)) {
+          parts.unshift(current.property.name);
+        }
+        current = current.object;
+      }
+      if (BabelTypes.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 (BabelTypes.isJSXAttribute(attr) && BabelTypes.isJSXIdentifier(attr.name)) {
+        const propName = attr.name.name;
+        if (attr.value === null) {
+          props[propName] = "true";
+        } else if (BabelTypes.isStringLiteral(attr.value)) {
+          props[propName] = attr.value.value;
+        } else if (BabelTypes.isJSXExpressionContainer(attr.value) && BabelTypes.isStringLiteral(attr.value.expression)) {
+          props[propName] = attr.value.expression.value;
+        }
+      }
+    }
+    return props;
+  }
+  extractAccessibilityProps(openingElement) {
+    const result = {};
+    for (const attr of openingElement.attributes) {
+      if (BabelTypes.isJSXAttribute(attr) && BabelTypes.isJSXIdentifier(attr.name)) {
+        const propName = attr.name.name;
+        if ((propName === "testID" || propName === "accessibilityLabel") && attr.value) {
+          if (BabelTypes.isStringLiteral(attr.value)) {
+            result[propName] = attr.value.value;
+          } else if (BabelTypes.isJSXExpressionContainer(attr.value) && BabelTypes.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 (BabelTypes.isJSXElement(child)) {
+        const component = this.extractComponentFromJSXElement(child);
+        if (component) {
+          extracted.push(component);
+        }
+      }
+    }
+    return extracted;
+  }
+};
+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 = readFileSync(filePath, "utf-8");
+      const ast = parser.parse(code, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript", ["decorators", { decoratorsBeforeExport: true }]]
+      });
+      this.stateVariables.clear();
+      this.inputElements = [];
+      this.submitButtons = [];
+      traverse4(ast, {
+        CallExpression: (path5) => {
+          this.extractStateVariables(path5.node);
+        }
+      });
+      traverse4(ast, {
+        JSXElement: (path5) => {
+          this.extractFormElements(path5.node);
+        }
+      });
+      const validationRules = this.extractValidationRules(ast);
+      return this.buildForms(filePath, validationRules);
+    } catch (error) {
+      console.error(`Failed to analyze forms in file ${filePath}:`, error);
+      return [];
+    }
+  }
+  extractStateVariables(node) {
+    if (BabelTypes.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 info = { varName: "" };
+    for (const attr of openingElement.attributes) {
+      if (BabelTypes.isJSXAttribute(attr) && BabelTypes.isJSXIdentifier(attr.name)) {
+        const propName = attr.name.name;
+        const propValue = this.extractAttributeValue(attr.value);
+        switch (propName) {
+          case "label":
+            info.label = propValue;
+            break;
+          case "placeholder":
+            info.placeholder = propValue;
+            break;
+          case "keyboardType":
+            info.keyboardType = propValue;
+            break;
+          case "testID":
+            info.testID = propValue;
+            break;
+          case "appilotsId":
+            info.appilotsId = propValue;
+            if (propValue) info.varName = propValue;
+            break;
+          case "value":
+            if (attr.value && BabelTypes.isJSXExpressionContainer(attr.value) && BabelTypes.isIdentifier(attr.value.expression)) {
+              info.varName = attr.value.expression.name;
+            }
+            break;
+        }
+      }
+    }
+    return info;
+  }
+  extractButtonInfo(openingElement) {
+    const info = {};
+    for (const attr of openingElement.attributes) {
+      if (BabelTypes.isJSXAttribute(attr) && BabelTypes.isJSXIdentifier(attr.name)) {
+        const propName = attr.name.name;
+        if (propName === "title" || propName === "label") {
+          info.label = this.extractAttributeValue(attr.value);
+        }
+        if (propName === "onPress") {
+          if (attr.value && BabelTypes.isJSXExpressionContainer(attr.value)) {
+            if (BabelTypes.isIdentifier(attr.value.expression)) {
+              info.handler = attr.value.expression.name;
+            } else if (BabelTypes.isArrowFunctionExpression(attr.value.expression) || BabelTypes.isFunctionExpression(attr.value.expression)) {
+              info.handler = "anonymous";
+            }
+          }
+        }
+      }
+    }
+    return Object.keys(info).length > 0 ? info : null;
+  }
+  extractAttributeValue(value) {
+    if (value === null) return void 0;
+    if (BabelTypes.isStringLiteral(value)) return value.value;
+    if (BabelTypes.isJSXExpressionContainer(value) && BabelTypes.isStringLiteral(value.expression)) {
+      return value.expression.value;
+    }
+    return void 0;
+  }
+  getElementName(openingElement) {
+    if (BabelTypes.isJSXIdentifier(openingElement.name)) {
+      return openingElement.name.name;
+    }
+    return null;
+  }
+  extractValidationRules(ast) {
+    const rules = {};
+    traverse4(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 (BabelTypes.isUnaryExpression(test) && test.operator === "!") {
+      if (BabelTypes.isCallExpression(test.argument)) {
+        const callExpr = test.argument;
+        if (BabelTypes.isMemberExpression(callExpr.callee)) {
+          const memberExpr = callExpr.callee;
+          if (BabelTypes.isIdentifier(memberExpr.object)) {
+            fieldName = memberExpr.object.name;
+            description = `${fieldName} is required`;
+          }
+        }
+      } else if (BabelTypes.isIdentifier(test.argument)) {
+        fieldName = test.argument.name;
+        description = `${fieldName} is required`;
+      }
+    }
+    if (BabelTypes.isBinaryExpression(test) && (test.operator === "<" || test.operator === "<=")) {
+      if (BabelTypes.isMemberExpression(test.left)) {
+        const memberExpr = test.left;
+        if (BabelTypes.isIdentifier(memberExpr.object)) {
+          fieldName = memberExpr.object.name;
+          if (BabelTypes.isNumericLiteral(test.right)) {
+            description = `${fieldName} must be at least ${test.right.value} characters`;
+          }
+        }
+      }
+    }
+    if (BabelTypes.isUnaryExpression(test) && test.operator === "!") {
+      if (BabelTypes.isCallExpression(test.argument) && BabelTypes.isMemberExpression(test.argument.callee)) {
+        const methodName = BabelTypes.isIdentifier(test.argument.callee.property) ? test.argument.callee.property.name : null;
+        if (methodName === "includes" && BabelTypes.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 = path4.basename(filePath, path4.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);
+  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;
+}
+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 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 glob(
+      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 = path4__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 (error) {
+        console.warn(`[MCPGenerator] Failed to analyze ${file}:`, error);
+        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 = path4__default.resolve(
+      outputDir,
+      `mcp-document.${this.options.format}`
+    );
+    await writeFile(filePath, serialized, "utf-8");
+    console.log(`[MCPGenerator] Document written to: ${filePath}`);
+    const checksumFilePath = path4__default.resolve(outputDir, ".appilots-checksum");
+    await 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 = path4__default.resolve(outputDir, ".appilots-checksum");
+    try {
+      const content = await readFile(checksumFilePath, "utf-8");
+      return content.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Calculate SHA-256 checksum of content
+   */
+  calculateChecksum(content) {
+    return 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 = path4__default.resolve(this.analyzerConfig.rootDir, "package.json");
+      const packageJsonContent = await 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 (error) {
+      console.warn("[MCPGenerator] Failed to read package.json, using default project name");
+      return { name: "Unknown Project" };
+    }
+  }
+};
+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(readFileSync(configPath, "utf-8"));
+    } catch (error) {
+      throw new Error(`Failed to parse .appilotsrc at ${configPath}: ${error instanceof Error ? error.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 = 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 {
+    writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to write .appilotsrc to ${configPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+function getConfigPath() {
+  let currentDir = resolve(process.cwd());
+  const root = resolve("/");
+  while (currentDir !== root) {
+    const configPath = join(currentDir, ".appilotsrc");
+    try {
+      if (existsSync(configPath) && statSync(configPath).isFile()) {
+        return configPath;
+      }
+    } catch {
+    }
+    currentDir = resolve(currentDir, "..");
+  }
+  const rootConfigPath = join(root, ".appilotsrc");
+  try {
+    if (existsSync(rootConfigPath) && 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/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/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 (error) {
+      return {
+        success: false,
+        unchanged: false,
+        error: error instanceof Error ? error.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 (error) {
+      return {
+        error: error instanceof Error ? error.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 (error) {
+      return {
+        error: error instanceof Error ? error.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;
+    }
+  }
+};
+
+export { AppilotsAPIClient, ComponentAnalyzer, FormAnalyzer, MCPGenerator, NavigationAnalyzer, ScreenAnalyzer, formatMetadataWarnings, getConfigPath, getEnvOverrides, lintActionMetadata, loadConfig, saveConfig, validateConfig };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map