@autoview/cli 0.1.0

package/README.md

@@ -0,0 +1,407 @@
+# AutoView
+
+**Read any OpenAPI document, prove it can actually be driven as a product, and
+emit the surfaces that drive it — a human frontend, an agent tool surface (MCP) —
+each verified to work.**
+
+```
+              ┌─▶  frontend/        a human admin UI (Next.js + shadcn/ui)
+swagger.json ─┼─▶  --emit mcp       an agent tool surface (runnable MCP server)
+   (any)      ├─▶  --emit report    consumability verdict (can this API be driven?)
+              └─▶  verify           proof it works (real browser / real agent)
+```
+
+AutoView reads an OpenAPI 3.x document into a deterministic **semantic model of
+the API** — its resources, their hierarchy, which endpoint produces the id
+another endpoint consumes, what is a read vs a mutation — and projects that one
+model into the surfaces that consume the API. Then it **verifies** them: the
+frontend's user journeys in a real browser, the agent's tasks against the live
+backend, and a static consumability report that flags ids no endpoint can supply.
+
+The point is not "a pretty generated screen" (that is a commodity). The point is
+**proof**: that your API is consumable as a product, demonstrated rather than
+asserted.
+
+AutoView is **standalone** and the whole READ → MAP → EMIT pipeline is
+**LLM-free and deterministic** — same document, same output, every time. The
+domain map, the screen set, and the page render are all derived structurally, so
+even a large swagger generates whole, un-sliced (Box's 234 operations → 142
+pages, DigitalOcean's 287 → 106, both typecheck-clean). A model you supply is
+used only as an optional typecheck-recovery pass during frontend generation, and
+for agent-task verification.
+
+<sub>Origin note: AutoView was first written inside the
+[AutoBE](https://github.com/wrtnlabs/autobe) monorepo and is published as
+`@autoview/cli`. All `@autobe/*` runtime dependencies have been removed.</sub>
+
+---
+
+## Table of contents
+
+- [The one idea](#the-one-idea)
+- [What it emits](#what-it-emits)
+- [From an AutoBE backend to a UI (demo workflow)](#from-an-autobe-backend-to-a-ui-demo-workflow)
+- [Quick start](#quick-start)
+- [Verification — proof, not assertion](#verification--proof-not-assertion)
+- [How it reads the API (the IR)](#how-it-reads-the-api-the-ir)
+- [CLI](#cli)
+- [Install & programmatic API](#install--programmatic-api)
+- [Verified on](#verified-on)
+- [Honest limits](#honest-limits)
+- [License](#license)
+
+---
+
+## The one idea
+
+Everything is one deterministic **IR** (intermediate representation — the API's
+semantic model) and several **emits** off it. Build the IR once; every surface
+and every check is a projection of it.
+
+```
+                       ┌── frontend   (human view)
+swagger ─▶  IR  ───────┼── tool surface / MCP  (agent view)
+            │          └── consumability report (verdict)
+            │
+            └── verification  (proves the emits actually work)
+```
+
+The IR carries, per operation: the resource it belongs to and the resource
+**hierarchy** (`sales → questions → comments`), its **role** (list / detail /
+create / update / delete / action → read vs write), and the **producer→consumer
+chain** (the `saleId` that `questions.list` needs is produced by `sales.list`'s
+`id`). That model is what a flat "OpenAPI → tools" or "OpenAPI → CRUD UI" dump
+lacks, and it is what makes the surfaces navigable and the report possible.
+
+---
+
+## What it emits
+
+| Emit | Command | For | LLM |
+| --- | --- | --- | --- |
+| **Frontend** | `autoview swagger.json --out ./frontend` | humans — a Next.js + shadcn/ui admin (sidebar nav, dense tables, detail views with actions, forms) | optional |
+| **Agent tool surface (MCP)** | `autoview swagger.json --emit mcp` | AI agents — a runnable MCP server; each tool carries read/write annotations and producer hints, and executes the real API over HTTP | none |
+| **Consumability report** | `autoview swagger.json --emit report` | API authors / CI — a deterministic verdict: every id a tool needs should be obtainable from another tool | none |
+| **Preview** | `autoview swagger.json --preview` | a quick look — the endpoint tree + schemas as one HTML page | none |
+
+All four read the **same IR**. The frontend and the MCP server are the same
+resource model rendered for two different consumers; the report is that model
+checked for navigability.
+
+> **Two different things are called a "mode" — don't conflate them.**
+> 1. **Emit mode** — *what AutoView produces*, chosen on the `autoview` command
+>    line (the four rows above: frontend / `--emit mcp` / `--emit report` /
+>    `--preview`).
+> 2. **Data mode** — *how the generated frontend runs*, chosen later at
+>    `npm run dev` time: **simulate** (typia-mock data, no backend —
+>    `NEXT_PUBLIC_API_SIMULATE=true`) or **live** (real backend —
+>    `NEXT_PUBLIC_API_HOST=<host>`). It is just an env toggle on the generated
+>    app, switchable without regenerating.
+>
+> For a demo you only touch one emit (frontend) and one data mode at a time
+> (simulate to always have populated screens; live when the backend is up).
+
+---
+
+## From an AutoBE backend to a UI (demo workflow)
+
+AutoBE generates a backend and its OpenAPI document. AutoView turns that document
+into a running Next.js admin you can open in a browser — the human-facing proof
+that the AutoBE backend actually works. The whole flow is four commands, and with
+`--no-llm` **no API key is needed at all** — the READ → MAP → render pipeline is
+fully deterministic.
+
+### 0 · One-time setup (in this repo)
+
+```bash
+npm install
+npm run build            # builds lib/cli/main.js — invoked below as `node lib/cli/main.js`
+```
+
+### 1 · Inspect the swagger first — instant
+
+```bash
+node lib/cli/main.js ./erp.swagger.json --preview --out ./out
+open ./out/preview.html          # endpoint tree + schemas + a READ-layer report
+```
+
+### 2 · Generate the frontend (no key)
+
+```bash
+node lib/cli/main.js ./erp.swagger.json --out ./erp-frontend --no-llm \
+  --backend https://your-erp-host
+```
+
+`--no-llm` generates everything deterministically — same swagger, same output,
+zero tokens. (Drop `--no-llm` and pass `--model`/`--api-key` only if you want the
+optional LLM pass that repairs a page on the rare chance the deterministic render
+does not typecheck.)
+
+- `--backend` is the live ERP host baked into `connection.ts`. Omit it and
+  AutoView auto-extracts `servers[0].url` from the swagger.
+- **Large ERP swagger?** Slice it — `--include` keeps only matching paths *and*
+  the component schemas they reference, so even a huge spec generates:
+  `--include "erp/admin/**,erp/inventory/**"` (or generate the whole thing; Box's
+  234 operations → 142 pages compiles clean).
+
+### 3 · Open it in the browser
+
+```bash
+cd erp-frontend && npm install
+
+# A) Guaranteed populated demo — typia-mock data, no backend needed:
+NEXT_PUBLIC_API_SIMULATE=true npm run dev          # → http://localhost:3000
+
+# B) Real data — against the live ERP backend (host must be reachable + allow CORS):
+NEXT_PUBLIC_API_HOST=https://your-erp-host npm run dev
+```
+
+For a demo where the backend might not be reachable, use **(A)** — every list,
+detail, and form renders with mock data so the whole UI is walkable. Switch to
+**(B)** the moment the real ERP host is up to show live rows.
+
+> **Tip for an ERP swagger with authentication:** in live mode the app may try to
+> bootstrap a session against the auth endpoints on first load. If that stalls
+> (host down, CORS, no seed account), demo in **simulate mode (A)** — it never
+> calls the backend, so the full UI is always walkable.
+
+**Common knobs**
+
+| Goal | Flag |
+| --- | --- |
+| Slice a huge ERP spec | `--include "erp/admin/**"` (and `--exclude` to drop noise) |
+| Force mock mode at generate time | `--backend=""` |
+| Inspect without generating | `--preview` (HTML) or `--emit report` (navigability verdict) |
+| Tune render concurrency | `--semaphore 8` |
+
+---
+
+## Quick start
+
+```bash
+npm install -g @autoview/cli     # installs the `autoview` command — or: npx @autoview/cli ...
+```
+
+**A human frontend** — deterministic, no key needed with `--no-llm`:
+
+```bash
+autoview ./swagger.json --out ./frontend --no-llm
+cd frontend && npm install && npm run dev        # http://localhost:3000
+```
+
+(Drop `--no-llm` and pass `--model`/`--api-key` to add the optional LLM
+typecheck-recovery pass.)
+
+**An agent tool surface (MCP server):**
+
+```bash
+autoview ./swagger.json --emit mcp --out ./mcp
+cd mcp && npm install
+API_HOST=https://api.example.com API_TOKEN="Bearer …" npm start
+```
+
+Then wire it into Claude Desktop / Cursor / Claude Code (the generated
+`README.md` has the exact `mcpServers` JSON).
+
+**A consumability verdict:**
+
+```bash
+autoview ./swagger.json --emit report --out ./out
+cat out/consumability-report.md
+```
+
+---
+
+## Verification — proof, not assertion
+
+A typecheck score is not proof a product works. AutoView verifies the emits the
+way a user (or an agent) actually exercises them.
+
+- **Frontend workflows** — `autoview … --verify` boots the generated app in a
+  real headless browser and walks the derived user journeys (open the list →
+  it renders rows or an honest empty state → open a record → its fields render),
+  writing `wiki/verification.md` with per-step pass/fail evidence.
+- **Agent tasks** — `verifyAgentTasks(document, { client, model, baseUrl, tasks })`
+  drives a real agent through named tasks against the tool surface + live
+  backend and grades each. The model and key are **injected by you** (e.g. from
+  `.env`) — which model your API's agents use is your call, not ours.
+- **Structural (LLM-free)** — `analyzeConsumability(document)` proves the tool
+  graph is navigable, with one model shared by the tool surface so the report
+  never claims navigability the tools don't hint. Each path-param input is one
+  of: **resolved** (a list/search tool produces the id and the surface says
+  which one), **nested** (the id appears inside a parent read's response —
+  `order` → `goods[].id` — navigable but not via a dedicated list), **orphan**
+  (an entity `*_id` no endpoint can supply — a genuine gap), **caller-supplied
+  key** (`repository_name`, `scope` — a human-known value, not a chained id), or
+  **undetermined** (the resource is read but no id could be traced, often an
+  inline schema). A detail read is never counted as its own producer (circular);
+  only true id orphans count as defects.
+
+That find-and-fix loop is the product: run it, and you get the surface **plus**
+the evidence it works — or exactly which step/endpoint breaks.
+
+### Run it yourself
+
+[`examples/verify-agent.ts`](examples/verify-agent.ts) verifies a swagger as an
+agent tool surface both ways — structurally (always) and behaviorally (when a
+model is configured):
+
+```bash
+npm run verify:agent                       # bundled petstore → public backend
+# or: npm run verify:agent ./your.json https://api.example.com
+```
+
+```
+── structural (deterministic) ──
+   18 tools — 8 read, 10 write
+   8 id inputs resolved · 0 orphan · 100% navigable
+
+── behavioral (openai/gpt-4o-mini → https://petstore3.swagger.io/api/v3) ──
+   PASS  list
+         tools: pet.findByStatus.get
+   PASS  producer→consumer chain
+         tools: pet.findByStatus.get → pet.getByPetid
+         answer: The pet's ID is 105484548 and its name is "modi".
+
+   2/2 tasks passed end-to-end (real agent, live backend).
+```
+
+The chain task is the point: the agent **lists** pets, takes an id **from the
+response**, and calls the **detail** endpoint with it — the producer→consumer
+link the tool surface declares, exercised against a live server. The structural
+pass runs with no key; the behavioral pass needs `AUTOVIEW_API_KEY` +
+`AUTOVIEW_MODEL` (the model is your choice).
+
+---
+
+## How it reads the API (the IR)
+
+```
+swagger.json
+   │
+   ▼  READ      fromSwagger() → toEndpoints()         (deterministic, LLM-free)
+   │            • upgrade Swagger 2 / OpenAPI 3.0/3.1 → one normalized document
+   │            • resolve $ref parameters (incl. cross-path JSON pointers),
+   │              flatten allOf composition, drop unroutable (`#`-fragment) paths
+   │            • every operation: method · path · accessor · path-params ·
+   │              QUERY · requestBody · responseBody
+   │
+   ▼  MAP       classifyEndpoints → resourcePlan       (deterministic, LLM-free)
+   │            • CRUD role per endpoint (read vs write)
+   │            • resource hierarchy / chain from the path
+   │            • producer→consumer links (which id comes from where)
+   │
+   ▼  EMIT      frontend page-gen · MCP tools · report  (deterministic)
+   │            + optional LLM typecheck-recovery pass on the frontend only
+   ▼
+  surfaces + verification
+```
+
+The READ and MAP layers — the IR — are 100% deterministic and reused by every
+emit. Robustness was hardened against real third-party specs: `$ref` parameter
+pointers (DigitalOcean), `allOf` composition and `entries`-style collection
+wrappers (Box), numeric ids, and `#`-fragment paths.
+
+---
+
+## CLI
+
+```
+autoview <swagger.json> [options]
+
+  --out <dir>           Output directory (default: ./frontend)
+  --emit mcp            Generate a runnable MCP server (agent tool surface). LLM-free.
+  --emit report         Write consumability-report.md (navigable graph + orphans). LLM-free.
+  --preview             Write preview.html (endpoint tree + schemas). LLM-free.
+  --verify              Verify the frontend in a real headless browser (user workflows).
+  --backend <url>       Live backend for the frontend's connection.ts / the report's hints.
+                        Auto-extracted from the swagger's servers[] when omitted.
+  --include <globs>     Comma-separated path globs to KEEP — slices the whole
+                        document (paths AND the component schemas they reference),
+                        so a large swagger fits the model and actually generates.
+  --exclude <globs>     Comma-separated path globs to DROP (applied after include).
+  --model <name>        LLM model (only for the optional frontend RENDER polish).
+  --api-key <key>       Vendor key (or AUTOVIEW_API_KEY / OPENAI_API_KEY env).
+  --base-url <url>      OpenAI-compatible endpoint (or AUTOVIEW_BASE_URL env).
+```
+
+`--emit`, `--report`, and `--preview` need no model or key — they are
+deterministic.
+
+---
+
+## Install & programmatic API
+
+```bash
+npm install @autoview/cli
+```
+
+```ts
+import {
+  fromSwagger,
+  buildToolSurface,        // IR → agent tools (read/write annotated, producer hints)
+  emitMcpServer,           // IR → a runnable MCP server project (files map)
+  analyzeConsumability,    // IR → navigable / orphan / undetermined breakdown
+  emitConsumabilityReport, // → markdown report
+  verifyAgentTasks,        // run an agent through tasks against the tool surface
+  AutoViewAgent,           // the frontend generator (optional LLM polish)
+} from "@autoview/cli";
+
+const document = fromSwagger(require("./swagger.json"));
+
+// agent tool surface + structural proof — no LLM, no network
+const tools = buildToolSurface(document);
+const coverage = analyzeConsumability(document);
+console.log(`${tools.length} tools, ${coverage.orphan.length} orphan inputs`);
+
+// a runnable MCP server, written to disk by the caller
+const files = emitMcpServer(document, { backend: "https://api.example.com" });
+```
+
+---
+
+## Verified on
+
+Real third-party OpenAPI documents, end-to-end:
+
+| Swagger | Domain | Ops | Frontend typecheck | Navigability (report) |
+| --- | --- | --- | --- | --- |
+| `@samchon/shopping` | e-commerce | 206 | 0 errors | 100% (203 resolved + 11 nested, 0 orphan) |
+| DigitalOcean | cloud infra | 287 | 0 errors (106 pages, whole) | 99% (146 resolved, 1 orphan; 47 undetermined, 52 caller-keys) |
+| Box | file platform | 234 | 0 errors (142 pages, whole) | 97% (77 resolved, 2 orphan; 84 undetermined, 19 caller-keys) |
+| Petstore | (canonical) | 18 | 0 errors (11 pages) | 100% (3 resolved, 0 orphan) |
+
+Frontend workflow verification (real browser): shopping 13/13 journeys pass,
+DigitalOcean 7/7. The emitted MCP server was driven end-to-end by a real MCP
+client; agent tasks pass against the tool surface with a configurable model.
+
+---
+
+## Honest limits
+
+- **Tool *shaping* helps exactly where the chain is hard to guess.** On a flat
+  1-hop chain (list → detail), a capable model reconstructs it from names alone,
+  so a naive surface chains about as well as the shaped one — shaping is not
+  magic there. But on a **nested** chain — an id buried in a parent's response
+  array (a sale's `units[].stocks[].id`) — the model cannot guess where the id
+  lives, and a naive surface fails. A blind A/B (same model, same backend;
+  [`examples/ab-nested-chain.ts`](examples/ab-nested-chain.ts), `npm run ab:nested`)
+  is decisive: **naive 0/5, shaped 5/5** — the naive agent blindly calls the deep
+  endpoint with ids it doesn't have; the shaped agent is told "stockId ← sale
+  detail at `units[].stocks[].id`" and gets it in two calls. So the durable value
+  is the **read/write safety annotations**, the **deterministic navigability
+  proof**, AND the **nested producer hints** that close chains a model can't infer.
+- **Inline response schemas are partly handled.** The producer→consumer analysis
+  now introspects inline object responses and resource-named collection wrappers
+  (`{ databases: [...] }`) including inline array items — lifting DigitalOcean's
+  navigability from 13% to 86%. Inputs it still cannot trace are reported as
+  *undetermined*, never as a defect.
+- **Frontend RENDER is deterministic by default.** The pages are generated from
+  the schema (one column per field, typed SDK wiring) — no LLM needed for a
+  working app. An LLM is only used for an optional aesthetic polish pass.
+
+---
+
+## License
+
+See [LICENSE](./LICENSE).

package/lib/AutoViewAgent.d.ts

@@ -0,0 +1,109 @@
+import { OpenApi } from "@typia/interface";
+import { IAgenticaVendor } from "@agentica/core";
+import { IAutoBeCompiler } from "./typings";
+import { AutoViewDispatchEvent } from "./context/IAutoViewAgentContext";
+/**
+ * Standalone entry point for the AutoView agent.
+ *
+ * Generates a runnable Next.js + shadcn/ui frontend from any
+ * {@link OpenApi.IDocument} — typically produced by passing a third party
+ * `swagger.json` through `@autobe/utils.invertOpenApiDocument`. Does not
+ * require `@autobe/agent`; the only requirement is an {@link IAgenticaVendor}
+ * (model + API key) and a compiler instance for SDK writing.
+ *
+ * Backward compat: `@autobe/agent`'s `AutoBeAgent.runAutoView()` still works as
+ * before — it bypasses this class and hands its own context to the same
+ * `orchestrateAutoView` directly.
+ */
+export interface IAutoViewAgentProps {
+    /**
+     * The OpenAPI document the frontend will be generated against. For a
+     * third-party Swagger payload, run it through `invertOpenApiDocument` from
+     * `@autobe/utils` first.
+     */
+    document: OpenApi.IDocument;
+    /**
+     * Agentica vendor — model + API key + optional semaphore. Same shape
+     * `@autobe/agent` accepts; the agent's quota-tracker / mistral-shim helpers
+     * are not wired here because they are AutoBE-specific.
+     */
+    vendor: IAgenticaVendor;
+    /**
+     * Optional design theme passed through to the Product Plan + Render phases.
+     * Empty / undefined means "prototype-first, content-first defaults".
+     */
+    designTheme?: string;
+    /**
+     * Compiler instance used to write the SDK files. Falls back to a fresh
+     * `AutoBeCompiler` when not provided. Pass your own instance if you want to
+     * share one across multiple AutoViewAgent runs in the same process.
+     */
+    compiler?: IAutoBeCompiler;
+    /** Concurrency cap for the per-screen render batch. Defaults to 8. */
+    semaphore?: number;
+    /**
+     * Live backend the generated frontend should connect to. When given, the
+     * scaffold wires `connection.ts` with `simulate: false` so the dev server
+     * renders real data on first boot — the standalone CLI's reason to exist.
+     *
+     * Omit to fall back to simulator mode (only useful for swaggers that
+     * genuinely have no backend). `extractBackendFromSwagger(payload)` in this
+     * package is a small helper for pulling the URL out of a swagger's
+     * `servers[0].url` field automatically.
+     */
+    backend?: {
+        host: string;
+    } | null;
+    /**
+     * Opt into Phase 6 runtime audit: after typecheck, boot `next dev`, walk
+     * every page with Playwright, and re-render any page that console-errored /
+     * crashed / failed to navigate. Catches the class of bugs `tsc --noEmit`
+     * cannot see (`obj?.array.method(...)` undefined-access, react render crashes
+     * on simulator data).
+     *
+     * Defaults to `false` because it installs Playwright + Chromium (~150MB) and
+     * boots `next dev` twice per agent run, adding ~10–20 minutes.
+     */
+    runtimeAudit?: boolean;
+    /**
+     * Opt into workflow verification: after typecheck, boot the generated app in
+     * a real headless browser and walk the derived user workflows, writing
+     * `wiki/verification.md`. Proves the app works for a user, not just compiles.
+     * Heavy (Chromium + `next dev`); defaults to `false`.
+     */
+    verify?: boolean;
+    /**
+     * Path globs to KEEP — only endpoints whose path matches become screens.
+     * Slices a large swagger to one actor surface, e.g.
+     * `["shoppings/customers/**"]`. Empty/absent means "all".
+     */
+    include?: string[];
+    /** Path globs to DROP after include, e.g. `["**​/monitors/**"]`. */
+    exclude?: string[];
+    /**
+     * Optional callback for every event the orchestrators dispatch
+     * (`autoViewStart`, `autoViewSdkStudy`, `autoViewProductPlan`,
+     * `autoViewScaffold`, per-page `autoViewRenderPage`, `autoViewReview`,
+     * `autoViewComplete`). Useful for progress bars, structured logging, etc.
+     */
+    onEvent?: (event: AutoViewDispatchEvent) => void;
+}
+/** Public result of {@link AutoViewAgent.run}. */
+export interface IAutoViewAgentResult {
+    /** Path → content map of the generated frontend project. */
+    files: Record<string, string>;
+}
+export declare class AutoViewAgent {
+    private readonly props;
+    constructor(props: IAutoViewAgentProps);
+    /**
+     * Drive every AutoView phase end-to-end and return the assembled frontend
+     * project as a flat `path → content` map.
+     *
+     * Mutates nothing on disk; serialize the map to ZIP, push it to a Sandbox, or
+     * write it out directly with `@autobe/filesystem` — your choice. The CLI
+     * binary (`bin/autoview`) does the disk-write step.
+     */
+    run(): Promise<IAutoViewAgentResult>;
+    private conversate;
+}

package/lib/AutoViewAgent.js

@@ -0,0 +1,123 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoViewAgent = void 0;
+const core_1 = require("@agentica/core");
+const AutoViewInterfaceCompiler_1 = require("./compiler/AutoViewInterfaceCompiler");
+const orchestrateAutoView_1 = require("./orchestrate/orchestrateAutoView");
+class AutoViewAgent {
+    constructor(props) {
+        this.props = props;
+    }
+    /**
+     * Drive every AutoView phase end-to-end and return the assembled frontend
+     * project as a flat `path → content` map.
+     *
+     * Mutates nothing on disk; serialize the map to ZIP, push it to a Sandbox, or
+     * write it out directly with `@autobe/filesystem` — your choice. The CLI
+     * binary (`bin/autoview`) does the disk-write step.
+     */
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            const compiler = (_a = this.props.compiler) !== null && _a !== void 0 ? _a : {
+                interface: new AutoViewInterfaceCompiler_1.AutoViewInterfaceCompiler(),
+            };
+            let captured = {};
+            const ctx = {
+                state: () => ({
+                    interface: { document: this.props.document, step: 0 },
+                }),
+                compiler: () => __awaiter(this, void 0, void 0, function* () { return compiler; }),
+                vendor: { semaphore: (_b = this.props.semaphore) !== null && _b !== void 0 ? _b : 8 },
+                dispatch: (event) => {
+                    var _a, _b;
+                    if (event.type === "autoViewComplete") {
+                        captured = event.files;
+                    }
+                    (_b = (_a = this.props).onEvent) === null || _b === void 0 ? void 0 : _b.call(_a, event);
+                    return event;
+                },
+                conversate: (cprops) => this.conversate(cprops),
+            };
+            yield (0, orchestrateAutoView_1.orchestrateAutoView)(ctx, {
+                source: "interface",
+                designTheme: this.props.designTheme,
+                backend: (_c = this.props.backend) !== null && _c !== void 0 ? _c : null,
+                runtimeAudit: (_d = this.props.runtimeAudit) !== null && _d !== void 0 ? _d : false,
+                verify: (_e = this.props.verify) !== null && _e !== void 0 ? _e : false,
+                include: this.props.include,
+                exclude: this.props.exclude,
+            });
+            return { files: captured };
+        });
+    }
+    conversate(cprops) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Minimal agentica wiring — no quota tracker, no vendor-specific
+            // shims, no compaction. The full AutoBE agent layers those on for
+            // its own concerns; the standalone path keeps things thin so it
+            // works against any OpenAI-compatible endpoint that supports tool
+            // calling.
+            const agent = new core_1.MicroAgentica({
+                vendor: this.props.vendor,
+                config: {
+                    executor: { describe: false },
+                    stream: cprops.enforceFunctionCall === false,
+                },
+                histories: cprops.histories,
+                controllers: [cprops.controller],
+            });
+            let tokenUsage = zeroTokenUsage();
+            const metric = {
+                attempt: 0,
+                success: 0,
+                invalidJson: 0,
+                validationFailure: 0,
+                consent: 0,
+            };
+            agent.on("call", () => {
+                metric.attempt++;
+            });
+            agent.on("execute", () => {
+                metric.success++;
+            });
+            agent.on("jsonParseError", () => {
+                metric.invalidJson++;
+            });
+            agent.on("validate", () => {
+                metric.validationFailure++;
+            });
+            yield agent.conversate(cprops.userMessage);
+            const usage = agent.getTokenUsage().aggregate;
+            tokenUsage = {
+                total: usage.total,
+                input: usage.input,
+                output: usage.output,
+            };
+            return { metric, tokenUsage };
+        });
+    }
+}
+exports.AutoViewAgent = AutoViewAgent;
+function zeroTokenUsage() {
+    return {
+        total: 0,
+        input: { total: 0, cached: 0 },
+        output: {
+            total: 0,
+            reasoning: 0,
+            accepted_prediction: 0,
+            rejected_prediction: 0,
+        },
+    };
+}
+//# sourceMappingURL=AutoViewAgent.js.map

package/lib/AutoViewAgent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoViewAgent.js","sourceRoot":"","sources":["../src/AutoViewAgent.ts"],"names":[],"mappings":"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"}

package/lib/agent/emitMcpServer.d.ts

@@ -0,0 +1,15 @@
+import { OpenApi } from "@typia/interface";
+/**
+ * Emit a runnable MCP (Model Context Protocol) server from an OpenAPI document —
+ * the agent-facing counterpart of the generated frontend. The server exposes the
+ * shaped tool surface (read/write annotations + producer hints) and, on a tool
+ * call, executes the real API over HTTP against the configured backend.
+ *
+ * Returns a flat `path → content` project map (server + package.json + README),
+ * the same shape the frontend scaffold returns, so the CLI writes it the same
+ * way. Deterministic: same document → same server.
+ */
+export declare function emitMcpServer(document: OpenApi.IDocument, options?: {
+    backend: string | null;
+    title?: string;
+}): Record<string, string>;