agent-manifest 3.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ayobami Adefolalu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# agentjson
+
+A universal CLI compiler that scans any web app codebase and generates a `public/agent.json` manifest — so AI agents can discover and interact with your app without custom integration work.
+
+Works with Next.js (App Router + Pages Router), Express, Hono, Fastify, and any TypeScript/JavaScript project with smart contracts.
+
+## Installation
+
+```bash
+# Run once, no install
+npx agent-manifest
+
+# Or install globally
+npm install -g agent-manifest
+```
+
+## Usage
+
+```bash
+# Scan current directory, output to public/agent.json
+agentjson
+
+# Specify project path and output
+agentjson -p ./my-app -o ./public/agent.json
+
+# With auth metadata
+agentjson --auth-type bearer --auth-header Authorization --auth-docs https://myapp.xyz/docs/auth
+
+# Add author / URL to manifest
+agentjson --author "0xDev" --url https://myapp.xyz
+
+# Validate an existing agent.json
+agentjson validate ./public/agent.json
+```
+
+## What gets generated
+
+```json
+{
+  "name": "FlipIt",
+  "description": "On-chain coin flip game",
+  "version": "1.0.0",
+  "author": "0xDev",
+  "url": "https://flipit.xyz",
+  "auth": { "type": "farcaster-frame" },
+  "capabilities": ["wallet", "payments"],
+  "actions": [
+    {
+      "name": "flip",
+      "description": "Flip a coin and bet ETH",
+      "intent": "game.play",
+      "type": "contract",
+      "location": "./src/abis/FlipABI.json",
+      "abiFunction": "flip",
+      "chainId": 8453,
+      "contractAddress": { "$env": "NEXT_PUBLIC_FLIP_ADDRESS" },
+      "safety": "financial",
+      "agentSafe": false,
+      "requiredAuth": { "required": "farcaster-signed" },
+      "inputs": {
+        "choice": { "type": "string", "enum": ["heads", "tails"], "required": true },
+        "amount":  { "type": "number", "required": true }
+      },
+      "outputs": { "type": "void" }
+    }
+  ],
+  "metadata": {}
+}
+```
+
+## Automatic detection
+
+### API routes
+- **Next.js App Router** — `app/api/**/route.ts` (GET, POST, PUT, DELETE, PATCH)
+- **Next.js Pages Router** — `pages/api/**/*.ts`
+- **Express / Hono / Fastify** — `app.get('/path', handler)` and `router.post(...)` patterns
+- **Server Actions** — `'use server'` files
+
+### Smart contracts
+- ABI JSON files (`*ABI.json`, `abi/*.json`, `abis/*.json`)
+- Wagmi hooks — `useWriteContract`, `useContractWrite`, `writeContract`
+- Contract addresses extracted as `{ "$env": "VAR_NAME" }` — secrets never embedded
+
+### Zod schemas
+- Inline `z.object(...)` schemas in the same file as `.parse()` / `.safeParse()`
+- **Cross-file** — schemas imported from centralised files (e.g. `src/lib/schemas.ts`) are resolved via the import graph
+
+### Auth
+- Detected from source code and `package.json` dependencies:
+  `bearer` · `api-key` · `oauth2` · `basic` · `farcaster-frame` · `cookie`
+- Override with `--auth-type` if detection misses
+
+### Capabilities
+`wallet` · `payments` · `ai` · `database` · `realtime` · `storage` · `farcaster`
+
+---
+
+## Safety levels
+
+Every action is classified automatically:
+
+| Level | Meaning | `agentSafe` |
+|---|---|---|
+| `read` | Read-only, no side effects | `true` |
+| `write` | Mutates state, no money movement | `true` |
+| `financial` | Moves tokens or value | `false` |
+| `destructive` | Deletes or burns irreversibly | `false` |
+| `confidential` | Handles PII, passwords, credentials, KYC | `false` |
+
+`agentSafe: false` means the agent must ask for human confirmation before executing.
+
+---
+
+## Intent taxonomy
+
+Actions get a `domain.verb` intent so agents understand what they do:
+
+| Domain | Examples |
+|---|---|
+| `game.*` | `game.play`, `game.join`, `game.score` |
+| `finance.*` | `finance.transfer`, `finance.swap`, `finance.stake`, `finance.approve` |
+| `nft.*` | `nft.mint`, `nft.burn`, `nft.list` |
+| `social.*` | `social.cast`, `social.follow`, `social.react`, `social.share` |
+| `governance.*` | `governance.vote`, `governance.propose`, `governance.delegate` |
+| `auth.*` | `auth.session`, `auth.register`, `auth.verify` |
+| `data.*` | `data.read`, `data.create`, `data.update`, `data.delete` |
+| `media.*` | `media.upload` |
+
+Override with a JSDoc tag: `@agent-action intent=custom.thing`
+
+---
+
+## Explicit annotation (optional)
+
+The compiler discovers actions automatically, but you can annotate for precision:
+
+```typescript
+/**
+ * @agent-action intent=game.play
+ * @description Flip a coin and bet ETH on the outcome.
+ * @param choice The side to bet on — "heads" or "tails".
+ * @param amount The amount of ETH to wager in wei.
+ */
+export async function flip(choice: string, amount: bigint) {
+  // ...
+}
+```
+
+---
+
+## Auth scopes
+
+Per-action auth is inferred automatically:
+
+| Condition | `requiredAuth` |
+|---|---|
+| Contract `view`/`pure` function | `public` |
+| GET endpoint on public app | `public` |
+| Farcaster frame app + write action | `farcaster-signed` |
+| Financial action | `required` + scope `payments:write` |
+| Confidential action (POST) | `required` + scope `pii:write` |
+| Confidential action (GET) | `required` + scope `pii:read` |
+| Everything else | `required` |
+
+---
+
+## CLI options
+
+```
+agentjson [options]
+
+Options:
+  -p, --path <path>         Project root (default: ".")
+  -o, --output <output>     Output path (default: "./public/agent.json")
+  --author <author>         Author name or organization
+  --url <url>               App homepage URL
+  --auth-type <type>        Override detected auth type
+                            none | bearer | api-key | oauth2 | basic | farcaster-frame | cookie
+  --auth-header <header>    Auth header name (default: Authorization)
+  --auth-docs <url>         URL where agents can obtain credentials
+  -V, --version             Show version
+  -h, --help                Show help
+
+Commands:
+  validate <file>           Validate an existing agent.json against the schema
+```
+
+---
+
+## JSON Schema
+
+A full JSON Schema is bundled at `node_modules/@0xdeve/agentjson/schema/agent.schema.json` for editor autocomplete and CI validation.
+
+---
+
+## Performance
+
+On large repos the compiler skips unchanged files using SHA-1 content hashing. Cache is stored in `.agentjson-cache.json` at the project root (add to `.gitignore`).
+
+---
+
+## License
+
+ISC

package/dist/cli.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_1 = require("./index");
+const program = new commander_1.Command();
+// ─── compile ─────────────────────────────────────────────────────────────────
+program
+    .name('agentjson')
+    .description('Universal agent manifest compiler — generates agent.json for any web app')
+    .version('3.1.0')
+    .option('-p, --path <path>', 'path to the project root', '.')
+    .option('-o, --output <output>', 'output path for agent.json', './public/agent.json')
+    .option('--author <author>', 'author name or organization')
+    .option('--url <url>', 'app homepage URL')
+    .option('--auth-type <type>', 'override detected auth type: none | bearer | api-key | oauth2 | basic | farcaster-frame | cookie')
+    .option('--auth-header <header>', 'auth header name (default: Authorization)')
+    .option('--auth-docs <url>', 'URL where agents can obtain credentials')
+    .action(async (options) => {
+    const projectPath = path.resolve(options.path);
+    const outputPath = path.resolve(options.output);
+    console.log(`🚀 Scanning project at: ${projectPath}`);
+    const discovery = new index_1.DiscoveryService(projectPath);
+    const files = await discovery.findRelevantFiles();
+    console.log(`🔍 Found ${files.length} relevant files.`);
+    const tsParser = new index_1.TSParser(projectPath);
+    const expressParser = new index_1.ExpressParser(tsParser.getProject());
+    const actions = [];
+    for (const file of files) {
+        console.log(`📄 Parsing: ${path.relative(projectPath, file)}`);
+        const fileActions = await tsParser.parseFile(file);
+        actions.push(...fileActions);
+        if (file.endsWith('.ts') || file.endsWith('.js')) {
+            try {
+                const content = fs.readFileSync(file, 'utf8');
+                if ((0, index_1.looksLikeRouteFile)(content)) {
+                    const expressActions = await expressParser.parseFile(file, projectPath);
+                    actions.push(...expressActions);
+                }
+            }
+            catch { /* ignore */ }
+        }
+    }
+    console.log(`✨ Detected ${actions.length} agent actions.`);
+    const uniqueActions = new Map();
+    for (const action of actions) {
+        const existing = uniqueActions.get(action.name);
+        if (!existing || Object.keys(action.inputs).length > Object.keys(existing.inputs).length) {
+            uniqueActions.set(action.name, action);
+        }
+    }
+    const appMetadata = tsParser.getAppMetadata();
+    if (options.author)
+        appMetadata.author = options.author;
+    if (options.url)
+        appMetadata.url = options.url;
+    const detectedAuth = tsParser.getAuth();
+    const auth = {
+        ...detectedAuth,
+        ...(options.authType && { type: options.authType }),
+        ...(options.authHeader && { header: options.authHeader }),
+        ...(options.authDocs && { docsUrl: options.authDocs }),
+    };
+    const generator = new index_1.ManifestGenerator();
+    const manifest = generator.generate(Array.from(uniqueActions.values()), appMetadata, tsParser.getCapabilities(), auth);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, JSON.stringify(manifest, null, 2));
+    console.log(`✅ agent.json generated at: ${outputPath}`);
+    console.log(`   ${uniqueActions.size} actions · ${manifest.capabilities.length} capabilities · auth: ${auth.type}`);
+});
+// ─── validate ────────────────────────────────────────────────────────────────
+program
+    .command('validate [file]')
+    .description('Validate an agent.json manifest against the schema')
+    .action((file = './public/agent.json') => {
+    const manifestPath = path.resolve(file);
+    if (!fs.existsSync(manifestPath)) {
+        console.error(`❌ File not found: ${manifestPath}`);
+        process.exit(1);
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    }
+    catch {
+        console.error(`❌ Invalid JSON in: ${manifestPath}`);
+        process.exit(1);
+    }
+    const errors = validateManifest(manifest);
+    if (errors.length === 0) {
+        console.log(`✅ ${manifestPath} is valid`);
+        console.log(`   ${manifest.actions.length} actions · ${manifest.capabilities.length} capabilities · auth: ${manifest.auth.type}`);
+    }
+    else {
+        console.error(`❌ Validation failed (${errors.length} error${errors.length > 1 ? 's' : ''}):`);
+        for (const err of errors)
+            console.error(`   • ${err}`);
+        process.exit(1);
+    }
+});
+// ─── Structural validator ────────────────────────────────────────────────────
+const SAFETY_LEVELS = new Set(['read', 'write', 'financial', 'destructive', 'confidential']);
+const ACTION_TYPES = new Set(['api', 'contract', 'function']);
+const AUTH_TYPES = new Set(['none', 'bearer', 'api-key', 'oauth2', 'basic', 'farcaster-frame', 'cookie']);
+const INTENT_RE = /^[a-z][a-z0-9]*\.[a-z][a-z0-9]*$/;
+function validateManifest(m) {
+    const errors = [];
+    if (typeof m.name !== 'string' || !m.name)
+        errors.push('`name` must be a non-empty string');
+    if (typeof m.version !== 'string' || !/^\d+\.\d+\.\d+$/.test(m.version))
+        errors.push('`version` must be a semver string');
+    if (!m.auth || !AUTH_TYPES.has(m.auth.type))
+        errors.push('`auth.type` must be one of: ' + [...AUTH_TYPES].join(' | '));
+    if (!Array.isArray(m.capabilities))
+        errors.push('`capabilities` must be an array');
+    if (!Array.isArray(m.actions))
+        errors.push('`actions` must be an array');
+    else {
+        m.actions.forEach((action, i) => {
+            const prefix = `actions[${i}] ("${action.name ?? '?'}")`;
+            if (!action.name)
+                errors.push(`${prefix}: missing \`name\``);
+            if (!action.intent)
+                errors.push(`${prefix}: missing \`intent\``);
+            else if (!INTENT_RE.test(action.intent))
+                errors.push(`${prefix}: \`intent\` must match domain.verb format`);
+            if (!ACTION_TYPES.has(action.type))
+                errors.push(`${prefix}: \`type\` must be one of api|contract|function`);
+            if (!SAFETY_LEVELS.has(action.safety))
+                errors.push(`${prefix}: \`safety\` must be one of read|write|financial|destructive|confidential`);
+            if (typeof action.agentSafe !== 'boolean')
+                errors.push(`${prefix}: \`agentSafe\` must be a boolean`);
+            if (!action.requiredAuth)
+                errors.push(`${prefix}: \`requiredAuth\` is missing`);
+        });
+    }
+    return errors;
+}
+program.parse();

package/dist/discovery/service.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const tinyglobby_1 = require("tinyglobby");
+const express_parser_1 = require("../parser/express-parser");
+/** SHA-1 of a file's content — used for change detection caching. */
+function fileHash(filePath) {
+    try {
+        return crypto.createHash('sha1').update(fs.readFileSync(filePath)).digest('hex');
+    }
+    catch {
+        return '';
+    }
+}
+const CACHE_FILE = '.agentjson-cache.json';
+/** Glob negations applied to every pattern to keep node_modules and build artifacts out. */
+const ALWAYS_EXCLUDE = [
+    '!**/node_modules/**',
+    '!**/.next/**',
+    '!**/dist/**',
+    '!**/.turbo/**',
+    '!**/.cache/**',
+    '!**/.git/**',
+    '!**/out/**',
+    '!**/build/**',
+    '!**/.vercel/**',
+    // Never scan env files — they may contain secrets
+    '!**/.env',
+    '!**/.env.*',
+    '!**/secrets/**',
+    '!**/credentials/**',
+];
+class DiscoveryService {
+    projectPath;
+    cache = {};
+    cachePath;
+    cacheModified = false;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+        this.cachePath = path.join(projectPath, CACHE_FILE);
+        this.loadCache();
+    }
+    loadCache() {
+        try {
+            this.cache = JSON.parse(fs.readFileSync(this.cachePath, 'utf8'));
+        }
+        catch {
+            this.cache = {};
+        }
+    }
+    saveCache() {
+        if (!this.cacheModified)
+            return;
+        try {
+            fs.writeFileSync(this.cachePath, JSON.stringify(this.cache, null, 2));
+        }
+        catch { /* ignore */ }
+    }
+    async findRelevantFiles() {
+        const relevantFiles = [];
+        // 0. Farcaster manifest (app identity / metadata)
+        const manifests = await (0, tinyglobby_1.glob)([
+            '.well-known/farcaster.json',
+            'public/.well-known/farcaster.json',
+            '**/public/.well-known/farcaster.json',
+        ], { cwd: this.projectPath, absolute: true });
+        relevantFiles.push(...manifests);
+        // 0.5. ABI JSON files (smart contract definitions)
+        const abis = await (0, tinyglobby_1.glob)([
+            '**/*ABI.json',
+            '**/abi/*.json',
+            '**/abis/*.json',
+            'contracts/*.json',
+            '**/contracts/*.json',
+            ...ALWAYS_EXCLUDE,
+        ], { cwd: this.projectPath, absolute: true });
+        relevantFiles.push(...abis);
+        // 1. API routes — support monorepo layouts (apps/*/src/app/api, apps/*/pages/api, etc.)
+        const apiRoutes = await (0, tinyglobby_1.glob)([
+            // Next.js App Router
+            '**/app/api/**/*.{ts,js,tsx,jsx}',
+            // Next.js Pages Router
+            '**/pages/api/**/*.{ts,js,tsx,jsx}',
+            // Generic api/ folder
+            '**/api/**/*.{ts,js,tsx,jsx}',
+            ...ALWAYS_EXCLUDE,
+        ], { cwd: this.projectPath, absolute: true });
+        relevantFiles.push(...apiRoutes);
+        // 2. Scan all TS/TSX files for signal keywords
+        const allTsFiles = await (0, tinyglobby_1.glob)([
+            '**/*.{ts,tsx}',
+            ...ALWAYS_EXCLUDE,
+        ], { cwd: this.projectPath, absolute: true });
+        for (const file of allTsFiles) {
+            if (relevantFiles.includes(file))
+                continue;
+            const hash = fileHash(file);
+            const cached = this.cache[file];
+            // Cache hit: file unchanged, reuse previous relevance decision
+            if (cached && cached.hash === hash) {
+                if (cached.relevant)
+                    relevantFiles.push(file);
+                continue;
+            }
+            // Cache miss: read and classify
+            const content = fs.readFileSync(file, 'utf8');
+            const relevant = content.includes('@agent-action') ||
+                content.includes('useWriteContract') ||
+                content.includes('useContractWrite') ||
+                content.includes('writeContract') ||
+                content.includes("'use server'") ||
+                content.includes('"use server"') ||
+                (0, express_parser_1.looksLikeRouteFile)(content);
+            this.cache[file] = { hash, relevant };
+            this.cacheModified = true;
+            if (relevant)
+                relevantFiles.push(file);
+        }
+        this.saveCache();
+        return Array.from(new Set(relevantFiles));
+    }
+}
+exports.DiscoveryService = DiscoveryService;

package/dist/generator/json.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestGenerator = void 0;
+class ManifestGenerator {
+    generate(actions, metadata = {}, capabilities = [], auth = { type: 'none' }, version = '1.0.0') {
+        return {
+            name: metadata.name ?? 'Web App',
+            description: metadata.description ?? 'Auto-generated agent manifest',
+            version,
+            ...(metadata.author && { author: metadata.author }),
+            ...(metadata.url && { url: metadata.url }),
+            auth,
+            metadata: {
+                ...(metadata.iconUrl && { iconUrl: metadata.iconUrl }),
+                ...(metadata.homeUrl && { homeUrl: metadata.homeUrl }),
+                ...(metadata.imageUrl && { imageUrl: metadata.imageUrl }),
+                ...(metadata.splashImageUrl && { splashImageUrl: metadata.splashImageUrl }),
+                ...(metadata.splashBackgroundColor && { splashBackgroundColor: metadata.splashBackgroundColor }),
+            },
+            capabilities,
+            actions,
+        };
+    }
+}
+exports.ManifestGenerator = ManifestGenerator;

package/dist/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityDetector = exports.AuthDetector = exports.ManifestGenerator = exports.ZodExtractor = exports.ContractParser = exports.looksLikeRouteFile = exports.ExpressParser = exports.TSParser = exports.DiscoveryService = void 0;
+__exportStar(require("./types"), exports);
+var service_1 = require("./discovery/service");
+Object.defineProperty(exports, "DiscoveryService", { enumerable: true, get: function () { return service_1.DiscoveryService; } });
+var ts_parser_1 = require("./parser/ts-parser");
+Object.defineProperty(exports, "TSParser", { enumerable: true, get: function () { return ts_parser_1.TSParser; } });
+var express_parser_1 = require("./parser/express-parser");
+Object.defineProperty(exports, "ExpressParser", { enumerable: true, get: function () { return express_parser_1.ExpressParser; } });
+Object.defineProperty(exports, "looksLikeRouteFile", { enumerable: true, get: function () { return express_parser_1.looksLikeRouteFile; } });
+var contract_parser_1 = require("./parser/contract-parser");
+Object.defineProperty(exports, "ContractParser", { enumerable: true, get: function () { return contract_parser_1.ContractParser; } });
+var zod_extractor_1 = require("./parser/zod-extractor");
+Object.defineProperty(exports, "ZodExtractor", { enumerable: true, get: function () { return zod_extractor_1.ZodExtractor; } });
+var json_1 = require("./generator/json");
+Object.defineProperty(exports, "ManifestGenerator", { enumerable: true, get: function () { return json_1.ManifestGenerator; } });
+var auth_detector_1 = require("./parser/auth-detector");
+Object.defineProperty(exports, "AuthDetector", { enumerable: true, get: function () { return auth_detector_1.AuthDetector; } });
+var capability_detector_1 = require("./parser/capability-detector");
+Object.defineProperty(exports, "CapabilityDetector", { enumerable: true, get: function () { return capability_detector_1.CapabilityDetector; } });
+__exportStar(require("./parser/intent-classifier"), exports);