@appilots/cli 0.1.0 → 0.4.0

package/dist/index.d.ts

@@ -519,6 +519,326 @@ declare class FormAnalyzer {
     private isFieldRequired;
 }
 
+/**
+ * Options that shape how a `PlatformAnalyzer` walks a project. These mirror
+ * the subset of `MCPGeneratorConfig` that today's React Native analyzer
+ * set already accepts — kept as a separate options bag (instead of the
+ * generator's whole config) so a future non-RN analyzer only needs to
+ * implement what's relevant to it.
+ */
+interface PlatformAnalyzerOptions {
+    /** §1: Only include files with registerScreen() or matching screen patterns. */
+    strictScreens?: boolean;
+    /** §1: Custom glob patterns for screen file detection. */
+    screenPatterns?: string[];
+    /** §5: Additional navigation file patterns (added to defaults). */
+    navigationInclude?: string[];
+    /** §5: Exclude patterns for navigation analysis. */
+    navigationExclude?: string[];
+}
+interface PlatformAnalyzerResult {
+    screens: ScreenDescriptor[];
+    navigation: NavigationGraph;
+    /** Number of source files matched by glob (before screen filtering). */
+    analyzedFiles: number;
+    /** Number of files excluded by strict screen filtering, when applicable. */
+    screensFilteredOut?: number;
+}
+/**
+ * Seam `MCPGenerator` consumes to turn a project's source tree into
+ * screens + a navigation graph. The React Native implementation
+ * (`ReactNativePlatformAnalyzer`) wraps the existing Babel/JSX analyzer
+ * pipeline (`ScreenAnalyzer` / `NavigationAnalyzer` / `ComponentAnalyzer` /
+ * `FormAnalyzer`) unchanged; a platform with no source-level analyzer yet
+ * (or a project with no JS/TSX at all) can use `GenericPlatformAnalyzer`,
+ * which is a safe no-op — screens then come entirely from the declared
+ * manifest (`appilots.manifest.json`, see `../manifest/loadManifest.ts`).
+ *
+ * `MCPGenerator` selects an implementation based on `.appilotsrc`'s
+ * `platform` field (default `'react-native'`) and merges its output with
+ * any declared manifest — the manifest wins on a screen-name conflict.
+ */
+interface PlatformAnalyzer {
+    /** Platform identifier this analyzer implements, e.g. `'react-native'`. */
+    readonly platform: string;
+    analyze(config: AnalyzerConfig, options: PlatformAnalyzerOptions): Promise<PlatformAnalyzerResult>;
+}
+
+/**
+ * Default `PlatformAnalyzer` implementation — the React Native Babel/JSX
+ * analyzer pipeline that existed inline in `MCPGenerator` before the
+ * platform-analyzer seam was introduced. This is a straight move: the
+ * orchestration (run `ScreenAnalyzer` + `NavigationAnalyzer`, glob every
+ * source file, run `ComponentAnalyzer` + `FormAnalyzer` per file, merge
+ * their output into each screen's forms/components) is unchanged, so
+ * output for existing React Native projects is byte-for-byte identical.
+ */
+declare class ReactNativePlatformAnalyzer implements PlatformAnalyzer {
+    readonly platform = "react-native";
+    analyze(config: AnalyzerConfig, options: PlatformAnalyzerOptions): Promise<PlatformAnalyzerResult>;
+    private mergeForm;
+    private findEquivalentField;
+    private mergeField;
+    private namedSubmitAction;
+    private isWeakInferredFieldName;
+    private findFormWithSharedFields;
+}
+
+/**
+ * `PlatformAnalyzer` for a platform with no source-level analyzer yet
+ * (anything other than `'react-native'` — Android/Kotlin, iOS/Swift, a
+ * web SPA, ...). It does zero filesystem work — no glob, no parsing — so
+ * it's safe to run on a project that has no JS/TSX at all. Screens for
+ * these platforms come entirely from the declared manifest
+ * (`appilots.manifest.json`); `MCPGenerator` merges the manifest on top
+ * of whatever this analyzer returns (nothing).
+ *
+ * This keeps the manifest-only integration path (deliverable §2) fully
+ * decoupled from `react-native`-specific tooling: a new platform can
+ * ship its own generator days before anyone writes a real AST analyzer
+ * for it.
+ */
+declare class GenericPlatformAnalyzer implements PlatformAnalyzer {
+    readonly platform: string;
+    constructor(platform: string);
+    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.
+ */
+declare const DEFAULT_MANIFEST_FILENAME = "appilots.manifest.json";
+/**
+ * A declared, hand-authored (or externally generated) application
+ * structure map — the manifest-mode integration path for any platform
+ * that doesn't have a source-level `PlatformAnalyzer` yet. Screens here
+ * use the exact same `ScreenDescriptor` shape the AST analyzers produce
+ * (validated against `@appilots/shared`'s `screenDescriptorSchema`, the
+ * same schema the formal `MCPDocument` wire contract uses), so a
+ * manifest and an AST-derived screen merge without any shape
+ * translation.
+ */
+interface AppilotsManifest {
+    /** Informational; not the MCPDocument's own `version` field. */
+    version?: string;
+    screens: ScreenDescriptor[];
+    /** Optional — merged into the analyzer-derived navigation graph. */
+    navigation?: Partial<NavigationGraph>;
+}
+interface LoadManifestResult {
+    /** `null` when no manifest file exists at the resolved path — not an error. */
+    manifest: AppilotsManifest | null;
+    /** Absolute path the manifest was (or would be) read from. */
+    resolvedPath: string;
+}
+/**
+ * Resolve and load `appilots.manifest.json` (or `manifestPath` from
+ * `.appilotsrc`) from `rootDir`. Returns `{ manifest: null }` when the
+ * file doesn't exist — manifest mode is opt-in, not required — but
+ * throws a descriptive error when the file exists and is unparseable
+ * JSON or fails `screenDescriptorSchema`/`navigationGraphSchema`
+ * validation, so a typo'd manifest fails loudly instead of silently
+ * contributing zero screens.
+ */
+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.
+ */
+declare function mergeManifestScreens(analyzerScreens: ScreenDescriptor[], manifestScreens: ScreenDescriptor[] | undefined): ScreenDescriptor[];
+/**
+ * Merge a declared manifest's (partial) navigation graph on top of the
+ * analyzer-derived one. Manifest entries win per-key; arrays are
+ * concatenated (manifest navigators appended after analyzer ones).
+ */
+declare function mergeManifestNavigation(analyzerNavigation: NavigationGraph, manifestNavigation: Partial<NavigationGraph> | undefined): NavigationGraph;
+
 interface MCPGeneratorOptions {
     /** Output format (only 'json' supported currently) */
     format: 'json';
@@ -596,12 +916,44 @@ interface MCPGeneratorConfig {
     include?: string[];
     /** Source exclude patterns */
     exclude?: string[];
+    /**
+     * Which `PlatformAnalyzer` to run against the source tree. Defaults to
+     * `'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;
+    /**
+     * Optional custom analyzer instance, mainly for tests. When set,
+     * `platform` is ignored for analyzer selection (but still recorded).
+     */
+    platformAnalyzer?: PlatformAnalyzer;
+    /**
+     * Path to a declared `appilots.manifest.json`, relative to `rootDir`
+     * unless absolute. Defaults to `appilots.manifest.json` at the project
+     * root. Manifest screens merge on top of analyzer-derived screens,
+     * winning on a screen-name conflict. Missing file is not an error —
+     * manifest mode is opt-in.
+     */
+    manifestPath?: string;
 }
 declare class MCPGenerator {
     private analyzerConfig;
     private options;
     private generatorConfig;
+    private platformAnalyzer;
     constructor(config: MCPGeneratorConfig);
+    /**
+     * Select the `PlatformAnalyzer` implementation for a `.appilotsrc`
+     * `platform` value. `'react-native'` (or unset — the existing default)
+     * 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 */
     generate(): Promise<MCPOutput>;
     /**
@@ -617,12 +969,6 @@ declare class MCPGenerator {
      * Calculate SHA-256 checksum of content
      */
     private calculateChecksum;
-    private mergeForm;
-    private findEquivalentField;
-    private mergeField;
-    private namedSubmitAction;
-    private isWeakInferredFieldName;
-    private findFormWithSharedFields;
     /**
      * Get project name and version from package.json in rootDir
      */
@@ -672,6 +1018,28 @@ interface AppilotsConfig {
      * Glob patterns to exclude from navigation analysis (§5).
      */
     navigationExclude?: string[];
+    /**
+     * 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. `'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;
+    /**
+     * Path to a declared `appilots.manifest.json`, relative to the
+     * project root unless absolute. Screens declared here (in the same
+     * `ScreenDescriptor` shape the analyzers produce) merge on top of
+     * analyzer-derived screens, winning on a name conflict. Default:
+     * `appilots.manifest.json` at the project root. A missing file is not
+     * an error — manifest mode is opt-in.
+     */
+    manifestPath?: string;
     /** `appilots eval` settings — see docs: Testing your agent between releases. */
     eval?: EvalConfig;
 }
@@ -888,4 +1256,4 @@ declare class AppilotsAPIClient {
     health(): Promise<boolean>;
 }
 
-export { type ActionDescriptor, type AnalyzerConfig, AppilotsAPIClient, type AppilotsConfig, ComponentAnalyzer, type ComponentDescriptor, type EnvOverrides, type FlowDescriptor, type FlowStepDescriptor, FormAnalyzer, type FormDescriptor, type FormFieldDescriptor, type LocatorDescriptor, type MCPDocument, MCPGenerator, type MCPGeneratorConfig, type MCPGeneratorOptions, type MCPOutput, type MetadataLintWarning, NavigationAnalyzer, type NavigationGraph, type NavigationNode, type NavigatorDescriptor, type ParamDescriptor, type ScreenAgentHints, ScreenAnalyzer, type ScreenDescriptor, type SignalDescriptor, type StatusResult, type SyncResult, type TargetDescriptor, type WaitPolicyDescriptor, formatMetadataWarnings, getConfigPath, getEnvOverrides, lintActionMetadata, loadConfig, saveConfig, validateConfig };
+export { type ActionDescriptor, type AnalyzerConfig, AppilotsAPIClient, type AppilotsConfig, type AppilotsManifest, 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 };