@appilots/cli 0.3.0 → 0.10.0

package/dist/index.d.ts

@@ -425,6 +425,14 @@ declare class ScreenAnalyzer {
     private extractNavigationParams;
     private extractItemFields;
     private inferItemType;
+    /**
+     * Identity comes from how a field is NAMED, not from what the app
+     * sells: `id`/`uuid`/`key`/`slug` are conventions any codebase uses,
+     * `name`/`title`/`email` are how any row introduces itself. `plate`
+     * used to sit in this list and read like one of them — but it is the
+     * example app's schema, and no other tenant ever got its equivalent
+     * (`mrn`, `trackingNumber`, `sku`) added here.
+     */
     private inferIdentityFields;
     private inferSearchField;
     /**
@@ -457,6 +465,26 @@ declare class NavigationAnalyzer {
     private findNavigationFiles;
     /** Parse navigator definitions from a file */
     private parseNavigators;
+    /**
+     * Is this JSX element `<navigatorVarName.MEMBER …>`?
+     */
+    private isNavigatorMember;
+    /**
+     * Flatten a navigator's JSX children into the `<X.Screen>` elements they
+     * contain, unwrapping every container a real app puts in between.
+     *
+     * The old version compared `t.isJSXElement(child)` against the direct
+     * children only. A ternary is a `JSXExpressionContainer`, so an
+     * auth-gated root — the modal shape of a commercial app, and the shape
+     * of this repo's own `apps/example-app` — contributed ZERO screens to
+     * the graph while `appilots sync` reported success (#396).
+     *
+     * Both branches of a conditional are collected on purpose. The graph is
+     * a design-time map of what routes EXIST, not a prediction of which one
+     * a given session will render; the agent needs the destination name to
+     * be there whether or not the user happens to be logged in right now.
+     */
+    private collectScreenElements;
     /** Extract screens from a navigator JSX element */
     private extractScreensFromNavigator;
     /** Extract string attribute value from JSX attributes */
@@ -604,6 +632,189 @@ declare class GenericPlatformAnalyzer implements PlatformAnalyzer {
     analyze(_config: AnalyzerConfig, _options: PlatformAnalyzerOptions): Promise<PlatformAnalyzerResult>;
 }
 
+/**
+ * `PlatformAnalyzer` for React web apps (`.appilotsrc` `platform:
+ * "web"`) — source-level inference instead of the manifest-only path
+ * `GenericPlatformAnalyzer` provides. Orchestrates:
+ *
+ *   - `WebScreenAnalyzer` — screens, forms, actions, collections from
+ *     DOM-vocabulary JSX (`onClick`, `data-testid`, `type=`, ...)
+ *   - `WebNavigationAnalyzer` — a navigation graph from React Router
+ *     configuration (`createBrowserRouter`, `<Route path element>`)
+ *
+ * The screen analyzer records navigation targets as ROUTE PATHS
+ * (`/vehicles/new`); this orchestrator owns the route table and
+ * resolves them to screen names, leaving unresolved paths as-is (still
+ * useful to the agent, and valid against the wire schema).
+ *
+ * Strict-screen filtering (on by default, like RN): a file counts as a
+ * screen when it calls `registerScreen()`, matches a screen glob
+ * (web defaults: `pages/`, `routes/`, `views/`, `app/`, `*Page`/
+ * `*Screen`/`*View`), or its component is rendered by a detected route
+ * — that last rule is what "the detected route patterns" adds over
+ * static globs.
+ *
+ * A declared `appilots.manifest.json` still merges ON TOP of this
+ * analyzer's output in `MCPGenerator` (manifest wins on a screen-name
+ * conflict) — same precedence as every other platform.
+ */
+declare class ReactWebPlatformAnalyzer implements PlatformAnalyzer {
+    readonly platform = "web";
+    analyze(config: AnalyzerConfig, options: PlatformAnalyzerOptions): Promise<PlatformAnalyzerResult>;
+    private isScreen;
+    /** Replace route-path references with screen names where the route table resolves them. */
+    private resolveRoutePaths;
+}
+
+/**
+ * One analyzed source file, before strict-screen filtering. The
+ * orchestrator (`ReactWebPlatformAnalyzer`) decides inclusion — it also
+ * knows the route table, so a file can qualify as a screen by being a
+ * route component even when it matches no glob pattern.
+ */
+interface WebScreenCandidate {
+    descriptor: ScreenDescriptor;
+    hasRegisterScreen: boolean;
+    matchesScreenPattern: boolean;
+}
+interface WebScreenAnalysis {
+    candidates: WebScreenCandidate[];
+    /** Files matched by the include globs (before screen filtering). */
+    analyzedFiles: number;
+}
+/**
+ * Default glob patterns that identify screen files in a web project —
+ * the RN defaults (`*Screen.tsx`, `screens/**`) don't match how web
+ * apps are laid out, so the web dialect looks at the conventional
+ * page/route/view directories instead.
+ */
+declare const DEFAULT_WEB_SCREEN_PATTERNS: string[];
+/**
+ * Web (DOM/JSX) sibling of `ScreenAnalyzer`. Same output contract
+ * (`ScreenDescriptor`), web-native vocabulary:
+ *
+ *   - actions come from `onClick`/`onSubmit` (not `onPress`)
+ *   - locators come from `data-testid`, `id`, `name`, `aria-label`, and
+ *     `<label htmlFor>` association (plus `appilotsId`, shared with RN)
+ *   - field types come from `type=` / `inputMode=` (not `keyboardType`)
+ *   - navigation targets come from React Router (`useNavigate`'s
+ *     `navigate('/x')`, `<Link to>`, `<Navigate to>`, internal `href`s);
+ *     they are recorded as ROUTE PATHS here and resolved to screen names
+ *     by the orchestrator, which owns the route table
+ */
+declare class WebScreenAnalyzer {
+    private config;
+    private verbose;
+    private screenPatterns;
+    constructor(config: AnalyzerConfig, options?: {
+        screenPatterns?: string[];
+    });
+    analyze(): Promise<WebScreenAnalysis>;
+    analyzeFile(filePath: string): Promise<WebScreenCandidate | null>;
+    private detectRegisterScreenCall;
+    private extractRegisterScreenMetadata;
+    /** Default-exported component name, else the first exported capitalized function. */
+    private extractComponentName;
+    private extractComponents;
+    private collectHtmlForLabels;
+    private extractForms;
+    private isSubmitElement;
+    private extractField;
+    private inferInputType;
+    private extractSelectOptions;
+    private mergeForms;
+    private extractActions;
+    private extractActionFromElement;
+    private mergeActionMetadata;
+    private enrichActionsFromHandlers;
+    /**
+     * Handler behavior via the shared, platform-neutral analyzer
+     * (async/await, `.then`, state setters, toasts, destructive verbs)
+     * plus the web-only signals: React Router navigation targets and
+     * `window.confirm(...)` as the native confirmation dialog.
+     */
+    private collectWebHandlerBehaviors;
+    private handlerNameFromAttr;
+    private extractNavigationTargets;
+    private extractCollections;
+}
+
+/**
+ * A single resolved React Router route: its full URL path and the screen
+ * (component) it renders. This is the web analog of a React Navigation
+ * `<Stack.Screen name=...>` entry.
+ */
+interface WebRoute {
+    /** Full path with parent segments joined, e.g. `/vehicles/:id`. */
+    path: string;
+    /** Screen name — the route component's name, or derived from the path. */
+    screenName: string;
+    /** Path params extracted from `:segment` placeholders. */
+    params?: ParamDescriptor[];
+    /** True for `<Route index>` / `{ index: true }` routes. */
+    index?: boolean;
+    /**
+     * True when this route has child routes — it renders a layout wrapper
+     * around them, not a page of its own. A layout route loses to its own
+     * `index` child when both resolve to the same path, since the index
+     * child is what the user actually lands on.
+     */
+    layout?: boolean;
+}
+interface WebNavigationResult {
+    graph: NavigationGraph;
+    routes: WebRoute[];
+}
+/**
+ * Analyzes React Router route configuration to build a navigation graph
+ * — the sibling of `NavigationAnalyzer` (which is 100% react-navigation
+ * and never runs for `platform: 'web'`). Understands both declaration
+ * styles:
+ *
+ *   - JSX: `<Routes><Route path="/x" element={<X/>}/></Routes>` (nested
+ *     `<Route>` children join their parent's path)
+ *   - Object config: `createBrowserRouter([{ path, element, children }])`
+ *     (also `createHashRouter`, `createMemoryRouter`, `useRoutes`)
+ */
+declare class WebNavigationAnalyzer {
+    private config;
+    private navigationInclude;
+    private navigationExclude;
+    constructor(config: AnalyzerConfig, options?: {
+        navigationInclude?: string[];
+        navigationExclude?: string[];
+    });
+    analyze(): Promise<WebNavigationResult>;
+    /** Files likely to contain route configuration. */
+    private findRouteFiles;
+    private extractJsxRoutes;
+    /** `element={<VehicleList/>}` or `Component={VehicleList}`. */
+    private componentNameFromElementAttr;
+    private extractObjectRoutes;
+    private visitRouteObjects;
+    private joinPaths;
+    private normalizePath;
+    private buildRoute;
+    private paramsFromPath;
+    /**
+     * One entry per path. When several declarations resolve to the same
+     * path, keep the one that best describes what the user lands on: a
+     * page beats a layout wrapper (an `index` child and its parent layout
+     * share a path), and a resolved component name beats a name derived
+     * from the path.
+     */
+    private dedupeRoutes;
+    private buildGraph;
+}
+/** `/vehicles/:id/edit` → `VehiclesIdEdit`; `/` → `Home`. */
+declare function screenNameFromPath(routePath: string): string;
+/**
+ * Match a navigated-to concrete path (e.g. `/vehicles/123`) against the
+ * route table, honoring `:param` segments. Returns the matched screen
+ * name, or undefined.
+ */
+declare function resolvePathToScreen(routes: WebRoute[], target: string): string | undefined;
+
 /**
  * Default manifest filename, resolved relative to the project's
  * `rootDir` unless `.appilotsrc`'s `manifestPath` overrides it.
@@ -644,9 +855,8 @@ interface LoadManifestResult {
 declare function loadManifest(rootDir: string, manifestPath?: string): Promise<LoadManifestResult>;
 /**
  * Merge a declared manifest's screens on top of analyzer-derived screens.
- * The manifest wins on a screen-name conflict (it's the developer's
- * explicit, authoritative statement); screens only one side knows about
- * pass through unchanged.
+ * A screen only one side knows about passes through unchanged; a screen
+ * both sides know is merged key by key (see `mergeScreen`).
  */
 declare function mergeManifestScreens(analyzerScreens: ScreenDescriptor[], manifestScreens: ScreenDescriptor[] | undefined): ScreenDescriptor[];
 /**
@@ -735,10 +945,11 @@ interface MCPGeneratorConfig {
     exclude?: string[];
     /**
      * Which `PlatformAnalyzer` to run against the source tree. Defaults to
-     * `'react-native'` (the existing Babel/JSX analyzer pipeline). Any
-     * other value runs `GenericPlatformAnalyzer` — a safe no-op that does
-     * no filesystem/AST work — so a platform with no source analyzer yet
-     * still produces a valid document from a declared manifest alone.
+     * `'react-native'` (the existing Babel/JSX analyzer pipeline). `'web'`
+     * runs `ReactWebPlatformAnalyzer` (DOM-vocabulary JSX + React Router).
+     * Any other value runs `GenericPlatformAnalyzer` — a safe no-op that
+     * does no filesystem/AST work — so a platform with no source analyzer
+     * yet still produces a valid document from a declared manifest alone.
      */
     platform?: string;
     /**
@@ -764,8 +975,10 @@ declare class MCPGenerator {
     /**
      * Select the `PlatformAnalyzer` implementation for a `.appilotsrc`
      * `platform` value. `'react-native'` (or unset — the existing default)
-     * gets the real Babel/JSX pipeline; anything else gets the no-op
-     * generic analyzer, relying entirely on a declared manifest.
+     * gets the RN Babel/JSX pipeline; `'web'` gets the React web (DOM +
+     * React Router) pipeline; anything else gets the no-op generic
+     * analyzer, relying entirely on a declared manifest. The manifest
+     * still merges on top of every analyzer's output either way.
      */
     static createPlatformAnalyzer(platform?: string): PlatformAnalyzer;
     /** Generate MCP documents from the project */
@@ -836,11 +1049,13 @@ interface AppilotsConfig {
      * Target platform for source analysis (multi-platform prep). Selects
      * which `PlatformAnalyzer` the generator runs and its default globs.
      * `'react-native'` (the default when unset) runs the existing
-     * Babel/JSX analyzer pipeline. Any other value (`'web'`, `'android'`,
-     * `'ios'`, a custom platform id, ...) runs a no-op analyzer that does
-     * no source parsing — screens for that platform come entirely from a
-     * declared manifest (see `manifestPath`). Forward-compatible: unknown
-     * values degrade gracefully instead of erroring.
+     * Babel/JSX analyzer pipeline. `'web'` runs the React web analyzer
+     * (DOM-vocabulary JSX + React Router route discovery). Any other
+     * value (`'android'`, `'ios'`, a custom platform id, ...) runs a
+     * no-op analyzer that does no source parsing — screens for that
+     * platform come entirely from a declared manifest (see
+     * `manifestPath`). Forward-compatible: unknown values degrade
+     * gracefully instead of erroring.
      */
     platform?: string;
     /**
@@ -872,6 +1087,12 @@ interface EvalConfig {
 interface ValidationResult {
     valid: boolean;
     errors: string[];
+    /**
+     * Non-fatal problems — today, keys the CLI does not understand. A typo
+     * here is silently ignored at load time and only surfaces much later as
+     * a confusing failure, so it is worth saying out loud.
+     */
+    warnings: string[];
 }
 /**
  * Environment overrides recognized by the CLI. Precedence when loading:
@@ -891,10 +1112,12 @@ declare function getEnvOverrides(env?: NodeJS.ProcessEnv): EnvOverrides;
  * environment variables (env wins). Works without a .appilotsrc when
  * APPILOTS_API_KEY is set, so CI can run `appilots sync` with env vars only.
  *
+ * @param onWarn Called once per non-fatal problem (unrecognized keys).
+ *   Commands pass the logger's `warn`; omitting it keeps loading silent.
  * @returns AppilotsConfig if a file or APPILOTS_API_KEY exists, null otherwise
  * @throws when the file is unparseable or the merged config fails validation
  */
-declare function loadConfig(): AppilotsConfig | null;
+declare function loadConfig(onWarn?: (message: string) => void): AppilotsConfig | null;
 /**
  * Saves configuration to .appilotsrc in the given directory
  *
@@ -952,12 +1175,26 @@ declare function formatMetadataWarnings(warnings: MetadataLintWarning[]): string
 interface SyncResult {
     success: boolean;
     unchanged: boolean;
+    /**
+     * Set by the server when an unchanged upload had to re-activate a
+     * document that was stored but not active — i.e. something else (an
+     * older version, a hand-activated document) was in front of the agent.
+     */
+    activated?: boolean;
     id?: string;
     checksum?: string;
     screensCount?: number;
     formsCount?: number;
     actionsCount?: number;
     error?: string;
+    /**
+     * The server's `error.code`, kept structured alongside the rendered
+     * `error` text so callers can branch on the failure instead of
+     * matching substrings. Absent when the failure produced no envelope.
+     */
+    errorCode?: string;
+    /** HTTP status of the failed response; 0 for network/timeout failures. */
+    errorStatus?: number;
 }
 /**
  * One eval scenario as sent to `POST /cli/eval/run`. Shape mirrors the
@@ -1019,11 +1256,21 @@ interface APIClientConfig {
     /** Retries on network errors / 5xx (default 2) */
     maxRetries?: number;
 }
-/**
- * HTTP client for communicating with Appilots API
- */
 declare class AppilotsAPIClient {
-    private serverUrl;
+    /**
+     * `serverUrl` with the API's mount prefix resolved — every path below
+     * is relative to THIS, not to the configured origin.
+     *
+     * It used to be the raw `serverUrl` with `/api/v1` hardcoded into each
+     * path, which made the field mean something different here than in the
+     * SDK. Both read the same `.appilotsrc`: the SDK completes the prefix
+     * when it is missing, so `https://api.appilots.com/api/v1` is correct
+     * there — and here that same value produced
+     * `/api/v1/api/v1/cli/sync`, a 404 whose body reads `Route not found`.
+     * Sharing `normalizeApiBaseUrl` is what makes one file mean one thing:
+     * with or without the prefix now works in both.
+     */
+    private baseUrl;
     private apiKey;
     private timeoutMs;
     private maxRetries;
@@ -1068,4 +1315,13 @@ declare class AppilotsAPIClient {
     health(): Promise<boolean>;
 }
 
-export { type ActionDescriptor, type AnalyzerConfig, AppilotsAPIClient, type AppilotsConfig, type AppilotsManifest, ComponentAnalyzer, type ComponentDescriptor, DEFAULT_MANIFEST_FILENAME, type EnvOverrides, type FlowDescriptor, type FlowStepDescriptor, FormAnalyzer, type FormDescriptor, type FormFieldDescriptor, GenericPlatformAnalyzer, type LoadManifestResult, type LocatorDescriptor, type MCPDocument, MCPGenerator, type MCPGeneratorConfig, type MCPGeneratorOptions, type MCPOutput, type MetadataLintWarning, NavigationAnalyzer, type NavigationGraph, type NavigationNode, type NavigatorDescriptor, type ParamDescriptor, type PlatformAnalyzer, type PlatformAnalyzerOptions, type PlatformAnalyzerResult, ReactNativePlatformAnalyzer, type ScreenAgentHints, ScreenAnalyzer, type ScreenDescriptor, type SignalDescriptor, type StatusResult, type SyncResult, type TargetDescriptor, type WaitPolicyDescriptor, formatMetadataWarnings, getConfigPath, getEnvOverrides, lintActionMetadata, loadConfig, loadManifest, mergeManifestNavigation, mergeManifestScreens, saveConfig, validateConfig };
+/**
+ * GENERATED by scripts/release/sync-sdk-versions.mjs — do not edit.
+ *
+ * The version `@appilots/cli` prints for `appilots --version` and in its
+ * banner. Kept identical to package.json by the release flow;
+ * `version.test.ts` fails if the two ever disagree.
+ */
+declare const CLI_VERSION = "0.10.0";
+
+export { type ActionDescriptor, type AnalyzerConfig, AppilotsAPIClient, type AppilotsConfig, type AppilotsManifest, CLI_VERSION, ComponentAnalyzer, type ComponentDescriptor, DEFAULT_MANIFEST_FILENAME, DEFAULT_WEB_SCREEN_PATTERNS, type EnvOverrides, type FlowDescriptor, type FlowStepDescriptor, FormAnalyzer, type FormDescriptor, type FormFieldDescriptor, GenericPlatformAnalyzer, type LoadManifestResult, type LocatorDescriptor, type MCPDocument, MCPGenerator, type MCPGeneratorConfig, type MCPGeneratorOptions, type MCPOutput, type MetadataLintWarning, NavigationAnalyzer, type NavigationGraph, type NavigationNode, type NavigatorDescriptor, type ParamDescriptor, type PlatformAnalyzer, type PlatformAnalyzerOptions, type PlatformAnalyzerResult, ReactNativePlatformAnalyzer, ReactWebPlatformAnalyzer, type ScreenAgentHints, ScreenAnalyzer, type ScreenDescriptor, type SignalDescriptor, type StatusResult, type SyncResult, type TargetDescriptor, type WaitPolicyDescriptor, WebNavigationAnalyzer, type WebNavigationResult, type WebRoute, WebScreenAnalyzer, formatMetadataWarnings, getConfigPath, getEnvOverrides, lintActionMetadata, loadConfig, loadManifest, mergeManifestNavigation, mergeManifestScreens, resolvePathToScreen, saveConfig, screenNameFromPath, validateConfig };