@getvision/adapter-hono 0.0.0-develop-20251031183955

package/.eslintrc.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  extends: ['@repo/eslint-config/library.js'],
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: true,
+  },
+}

package/.turbo/turbo-build.log

@@ -0,0 +1 @@
+$ tsc

package/README.md

@@ -0,0 +1,108 @@
+# @getvision/adapter-hono
+
+Hono.js adapter for Vision Dashboard.
+
+## Installation
+
+```bash
+pnpm add @getvision/adapter-hono
+```
+
+## Usage
+
+### Option 1: Auto-discovery (Recommended) ✨
+
+Routes are automatically discovered - no manual registration needed!
+
+```typescript
+import { Hono } from 'hono'
+import { visionAdapter, enableAutoDiscovery } from '@getvision/adapter-hono'
+
+const app = new Hono()
+
+// Add Vision Dashboard (development only)
+if (process.env.NODE_ENV !== 'production') {
+  app.use('*', visionAdapter({
+    port: 9500,
+    enabled: true,
+  }))
+  
+  // Enable auto-discovery
+  enableAutoDiscovery(app)
+}
+
+// Your routes - automatically registered!
+app.get('/hello', (c) => c.json({ hello: 'world' }))
+app.post('/users', (c) => c.json({ success: true }))
+
+export default app
+```
+
+### Option 2: Manual Registration
+
+If you prefer explicit control:
+
+```typescript
+import { Hono } from 'hono'
+import { visionAdapter, registerRoutes } from '@getvision/adapter-hono'
+
+const app = new Hono()
+
+if (process.env.NODE_ENV !== 'production') {
+  app.use('*', visionAdapter({ port: 9500 }))
+}
+
+app.get('/hello', (c) => c.json({ hello: 'world' }))
+app.post('/users', (c) => c.json({ success: true }))
+
+// Manually register routes
+if (process.env.NODE_ENV !== 'production') {
+  registerRoutes([
+    { method: 'GET', path: '/hello', handler: 'hello' },
+    { method: 'POST', path: '/users', handler: 'createUser' },
+  ])
+}
+
+export default app
+```
+
+## Options
+
+```typescript
+interface VisionHonoOptions {
+  port?: number        // Dashboard port (default: 9500)
+  enabled?: boolean    // Enable/disable adapter (default: true)
+  maxTraces?: number   // Max traces to store (default: 1000)
+}
+```
+
+## Features
+
+- ✅ **Automatic request tracing** - Every request is traced
+- ✅ **Error tracking** - Exceptions are captured in traces
+- ✅ **Query params** - Automatically logged
+- ✅ **Response status** - Tracked in spans
+- ✅ **Zero config** - Just add middleware and go!
+
+## How it works
+
+The adapter:
+
+1. Starts Vision WebSocket server on specified port
+2. Wraps each request in a trace
+3. Creates spans with timing information
+4. Captures errors and attributes
+5. Broadcasts traces to dashboard in real-time
+
+## Dashboard
+
+Once running, open `http://localhost:9500` to see:
+
+- Real-time request traces
+- Request/response details
+- Error tracking
+- Performance metrics
+
+## Example
+
+See [examples/hono-basic](../../examples/hono) for a complete example.

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import type { MiddlewareHandler } from 'hono';
+import { VisionCore } from '@getvision/core';
+import type { VisionHonoOptions, ServiceDefinition } from '@getvision/core';
+interface VisionContext {
+    vision: VisionCore;
+    traceId: string;
+}
+/**
+ * Get current vision context (vision instance and traceId)
+ * Available in route handlers when using visionAdapter
+ *
+ * @example
+ * ```ts
+ * app.get('/users', async (c) => {
+ *   const { vision, traceId } = getVisionContext()
+ *   const withSpan = vision.createSpanHelper(traceId)
+ *   // ...
+ * })
+ * ```
+ */
+export declare function getVisionContext(): VisionContext;
+/**
+ * Create span helper using current trace context
+ * Shorthand for: getVisionContext() + vision.createSpanHelper()
+ *
+ * @example
+ * ```ts
+ * app.get('/users', async (c) => {
+ *   const withSpan = useVisionSpan()
+ *
+ *   const users = withSpan('db.select', { 'db.table': 'users' }, () => {
+ *     return db.select().from(users).all()
+ *   })
+ * })
+ * ```
+ */
+export declare function useVisionSpan(): <T>(name: string, attributes: Record<string, any> | undefined, fn: () => T) => T;
+export declare function visionAdapter(options?: VisionHonoOptions): MiddlewareHandler;
+/**
+ * Enable auto-discovery of routes (experimental)
+ * Patches Hono app methods to automatically register routes
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ * app.use('*', visionAdapter())
+ * enableAutoDiscovery(app)
+ *
+ * // Routes defined after this will be auto-discovered
+ * app.get('/hello', (c) => c.json({ hello: 'world' }))
+ * ```
+ */
+export declare function enableAutoDiscovery(app: any, options?: {
+    services?: ServiceDefinition[];
+}): void;
+/**
+ * Get the Vision instance (for advanced usage)
+ */
+export declare function getVisionInstance(): VisionCore | null;
+export { zValidator } from './zod-validator';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,iBAAiB,EAAE,MAAM,MAAM,CAAA;AACtD,OAAO,EACL,UAAU,EAOX,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAiB,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAM1F,UAAU,aAAa;IACrB,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;CAChB;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,CAMhD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,qFAG5B;AAyID,wBAAgB,aAAa,CAAC,OAAO,GAAE,iBAAsB,GAAG,iBAAiB,CAwOhF;AAqGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,iBAAiB,EAAE,CAAA;CAAE,QAGzF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,UAAU,GAAG,IAAI,CAErD;AAID,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -0,0 +1,491 @@
+import { VisionCore, generateZodTemplate, autoDetectPackageInfo, autoDetectIntegrations, detectDrizzle, startDrizzleStudio, stopDrizzleStudio, } from '@getvision/core';
+import { AsyncLocalStorage } from 'async_hooks';
+import { extractSchema } from './zod-validator';
+const visionContext = new AsyncLocalStorage();
+/**
+ * Get current vision context (vision instance and traceId)
+ * Available in route handlers when using visionAdapter
+ *
+ * @example
+ * ```ts
+ * app.get('/users', async (c) => {
+ *   const { vision, traceId } = getVisionContext()
+ *   const withSpan = vision.createSpanHelper(traceId)
+ *   // ...
+ * })
+ * ```
+ */
+export function getVisionContext() {
+    const context = visionContext.getStore();
+    if (!context) {
+        throw new Error('Vision context not available. Make sure visionAdapter middleware is enabled.');
+    }
+    return context;
+}
+/**
+ * Create span helper using current trace context
+ * Shorthand for: getVisionContext() + vision.createSpanHelper()
+ *
+ * @example
+ * ```ts
+ * app.get('/users', async (c) => {
+ *   const withSpan = useVisionSpan()
+ *
+ *   const users = withSpan('db.select', { 'db.table': 'users' }, () => {
+ *     return db.select().from(users).all()
+ *   })
+ * })
+ * ```
+ */
+export function useVisionSpan() {
+    const { vision, traceId } = getVisionContext();
+    return vision.createSpanHelper(traceId);
+}
+/**
+ * Hono adapter for Vision Dashboard
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { visionAdapter } from '@vision/adapter-hono'
+ *
+ * const app = new Hono()
+ *
+ * if (process.env.NODE_ENV === 'development') {
+ *   app.use('*', visionAdapter({ port: 9500 }))
+ * }
+ * ```
+ */
+// Global Vision instance to share across middleware
+let visionInstance = null;
+const discoveredRoutes = [];
+let registerTimer = null;
+function scheduleRegistration(options) {
+    if (!visionInstance)
+        return;
+    if (registerTimer)
+        clearTimeout(registerTimer);
+    registerTimer = setTimeout(() => {
+        if (!visionInstance || discoveredRoutes.length === 0)
+            return;
+        visionInstance.registerRoutes(discoveredRoutes);
+        const grouped = groupRoutesByServices(discoveredRoutes, options?.services);
+        const services = Object.values(grouped);
+        visionInstance.registerServices(services);
+        console.log(`📋 Auto-discovered ${discoveredRoutes.length} routes (${services.length} services)`);
+    }, 100);
+}
+/**
+ * Auto-discover routes by patching Hono app methods
+ */
+function patchHonoApp(app, options) {
+    const methods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head'];
+    methods.forEach(method => {
+        const original = app[method];
+        if (original) {
+            app[method] = function (path, ...handlers) {
+                // Try to extract Zod schema from zValidator middleware
+                let requestBodySchema = undefined;
+                for (const handler of handlers) {
+                    const schema = extractSchema(handler);
+                    if (schema) {
+                        requestBodySchema = generateZodTemplate(schema);
+                        break;
+                    }
+                }
+                // Register route with Vision
+                discoveredRoutes.push({
+                    method: method.toUpperCase(),
+                    path,
+                    handler: handlers[handlers.length - 1]?.name || 'anonymous',
+                    middleware: [],
+                    requestBody: requestBodySchema,
+                });
+                // Call original method
+                const result = original.call(this, path, ...handlers);
+                scheduleRegistration(options);
+                return result;
+            };
+        }
+    });
+    // Patch routing of child apps to capture their routes with base prefix
+    const originalRoute = app.route;
+    if (originalRoute && typeof originalRoute === 'function') {
+        app.route = function (base, child) {
+            // Attempt to read child routes and register them with base prefix
+            try {
+                const routes = child?.routes;
+                if (Array.isArray(routes)) {
+                    for (const r of routes) {
+                        const method = (r?.method || r?.methods?.[0] || '').toString().toUpperCase() || 'GET';
+                        const rawPath = r?.path || r?.pattern?.path || r?.pattern || '/';
+                        const childPath = typeof rawPath === 'string' ? rawPath : '/';
+                        const normalizedBase = base.endsWith('/') ? base.slice(0, -1) : base;
+                        const normalizedChild = childPath === '/' ? '' : (childPath.startsWith('/') ? childPath : `/${childPath}`);
+                        const fullPath = `${normalizedBase}${normalizedChild}` || '/';
+                        discoveredRoutes.push({
+                            method,
+                            path: fullPath,
+                            handler: r?.handler?.name || 'anonymous',
+                            middleware: [],
+                        });
+                    }
+                    scheduleRegistration(options);
+                }
+            }
+            catch { }
+            return originalRoute.call(this, base, child);
+        };
+    }
+}
+/**
+ * Resolve endpoint template (e.g. /users/:id) for a concrete path
+ */
+function resolveEndpointTemplate(method, concretePath) {
+    const candidates = discoveredRoutes.filter((r) => r.method === method.toUpperCase());
+    for (const r of candidates) {
+        const pattern = '^' + r.path.replace(/:[^/]+/g, '[^/]+') + '$';
+        const re = new RegExp(pattern);
+        if (re.test(concretePath)) {
+            return { endpoint: r.path, handler: r.handler || 'anonymous' };
+        }
+    }
+    return { endpoint: concretePath, handler: 'anonymous' };
+}
+/**
+ * Extract params by comparing template path with concrete path
+ * e.g. template=/users/:id, concrete=/users/123 => { id: '123' }
+ */
+function extractParams(template, concrete) {
+    const tParts = template.split('/').filter(Boolean);
+    const cParts = concrete.split('/').filter(Boolean);
+    if (tParts.length !== cParts.length)
+        return undefined;
+    const result = {};
+    tParts.forEach((seg, i) => {
+        if (seg.startsWith(':')) {
+            result[seg.slice(1)] = cParts[i];
+        }
+    });
+    return Object.keys(result).length ? result : undefined;
+}
+export function visionAdapter(options = {}) {
+    const { enabled = true, port = 9500, maxTraces = 1000, logging = true } = options;
+    if (!enabled) {
+        return async (c, next) => await next();
+    }
+    // Initialize Vision Core once
+    if (!visionInstance) {
+        visionInstance = new VisionCore({ port, maxTraces });
+        // Auto-detect service info
+        const pkgInfo = autoDetectPackageInfo();
+        const autoIntegrations = autoDetectIntegrations();
+        // Merge with user-provided config
+        const serviceName = options.service?.name || options.name || pkgInfo.name;
+        const serviceVersion = options.service?.version || pkgInfo.version;
+        const serviceDesc = options.service?.description;
+        const integrations = {
+            ...autoIntegrations,
+            ...options.service?.integrations,
+        };
+        // Filter out undefined values from integrations
+        const cleanIntegrations = {};
+        for (const [key, value] of Object.entries(integrations)) {
+            if (value !== undefined) {
+                cleanIntegrations[key] = value;
+            }
+        }
+        // Detect and optionally start Drizzle Studio
+        const drizzleInfo = detectDrizzle();
+        let drizzleStudioUrl;
+        if (drizzleInfo.detected) {
+            console.log(`🗄️  Drizzle detected (${drizzleInfo.configPath})`);
+            if (options.drizzle?.autoStart) {
+                const drizzlePort = options.drizzle.port || 4983;
+                const started = startDrizzleStudio(drizzlePort);
+                if (started) {
+                    // Drizzle Studio uses local.drizzle.studio domain (with HTTPS)
+                    drizzleStudioUrl = 'https://local.drizzle.studio';
+                }
+            }
+            else {
+                console.log('💡 Tip: Enable Drizzle Studio auto-start with drizzle: { autoStart: true }');
+                drizzleStudioUrl = 'https://local.drizzle.studio';
+            }
+        }
+        // Set app status with service metadata
+        visionInstance.setAppStatus({
+            name: serviceName,
+            version: serviceVersion,
+            description: serviceDesc,
+            running: true,
+            pid: process.pid,
+            metadata: {
+                framework: 'hono',
+                integrations: Object.keys(cleanIntegrations).length > 0 ? cleanIntegrations : undefined,
+                drizzle: drizzleInfo.detected
+                    ? {
+                        detected: true,
+                        configPath: drizzleInfo.configPath,
+                        studioUrl: drizzleStudioUrl,
+                        autoStarted: options.drizzle?.autoStart || false,
+                    }
+                    : undefined,
+            },
+        });
+        // Cleanup on exit
+        process.on('SIGINT', () => {
+            stopDrizzleStudio();
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            stopDrizzleStudio();
+            process.exit(0);
+        });
+    }
+    const vision = visionInstance;
+    // Middleware to trace requests
+    return async (c, next) => {
+        // Skip tracing for OPTIONS requests (CORS preflight)
+        if (c.req.method === 'OPTIONS') {
+            return next();
+        }
+        const startTime = Date.now();
+        // Create trace
+        const trace = vision.createTrace(c.req.method, c.req.path);
+        // Run request in AsyncLocalStorage context
+        return visionContext.run({ vision, traceId: trace.id }, async () => {
+            // Also add to Hono context for compatibility
+            c.set('vision', vision);
+            c.set('traceId', trace.id);
+            // Start main span
+            const tracer = vision.getTracer();
+            const span = tracer.startSpan('http.request', trace.id);
+            // Add request attributes
+            tracer.setAttribute(span.id, 'http.method', c.req.method);
+            tracer.setAttribute(span.id, 'http.path', c.req.path);
+            tracer.setAttribute(span.id, 'http.url', c.req.url);
+            // Add query params if any
+            const url = new URL(c.req.url);
+            if (url.search) {
+                tracer.setAttribute(span.id, 'http.query', url.search);
+            }
+            // Capture request metadata (headers, query, body if json)
+            try {
+                const rawReq = c.req.raw;
+                const headers = {};
+                rawReq.headers.forEach((v, k) => { headers[k] = v; });
+                const urlObj = new URL(c.req.url);
+                const query = {};
+                urlObj.searchParams.forEach((v, k) => { query[k] = v; });
+                let body = undefined;
+                const ct = headers['content-type'] || headers['Content-Type'];
+                if (ct && ct.includes('application/json')) {
+                    try {
+                        body = await rawReq.clone().json();
+                    }
+                    catch { }
+                }
+                const sessionId = headers['x-vision-session'];
+                if (sessionId) {
+                    tracer.setAttribute(span.id, 'session.id', sessionId);
+                    trace.metadata = { ...(trace.metadata || {}), sessionId };
+                }
+                const requestMeta = {
+                    method: c.req.method,
+                    url: urlObj.pathname + (urlObj.search || ''),
+                    headers,
+                    query: Object.keys(query).length ? query : undefined,
+                    body,
+                };
+                tracer.setAttribute(span.id, 'http.request', requestMeta);
+                // Also mirror to trace-level metadata for convenience
+                trace.metadata = { ...(trace.metadata || {}), request: requestMeta };
+                // Emit start log (if enabled)
+                if (logging) {
+                    const { endpoint, handler } = resolveEndpointTemplate(c.req.method, c.req.path);
+                    const params = extractParams(endpoint, c.req.path);
+                    const parts = [
+                        `method=${c.req.method}`,
+                        `endpoint=${endpoint}`,
+                        `service=${handler}`,
+                    ];
+                    if (params)
+                        parts.push(`params=${JSON.stringify(params)}`);
+                    if (Object.keys(query).length)
+                        parts.push(`query=${JSON.stringify(query)}`);
+                    if (trace.metadata?.sessionId)
+                        parts.push(`sessionId=${trace.metadata.sessionId}`);
+                    parts.push(`traceId=${trace.id}`);
+                    console.info(`INF starting request ${parts.join(' ')}`);
+                }
+                // Execute request
+                await next();
+                // Add response attributes
+                tracer.setAttribute(span.id, 'http.status_code', c.res.status);
+                const resHeaders = {};
+                c.res.headers?.forEach((v, k) => { resHeaders[k] = v; });
+                let respBody = undefined;
+                const resCt = c.res.headers?.get('content-type') || '';
+                try {
+                    const clone = c.res.clone();
+                    if (resCt.includes('application/json')) {
+                        const txt = await clone.text();
+                        if (txt && txt.length <= 65536) {
+                            try {
+                                respBody = JSON.parse(txt);
+                            }
+                            catch {
+                                respBody = txt;
+                            }
+                        }
+                    }
+                }
+                catch { }
+                const responseMeta = {
+                    status: c.res.status,
+                    headers: Object.keys(resHeaders).length ? resHeaders : undefined,
+                    body: respBody,
+                };
+                tracer.setAttribute(span.id, 'http.response', responseMeta);
+                trace.metadata = { ...(trace.metadata || {}), response: responseMeta };
+            }
+            catch (error) {
+                // Track error
+                tracer.addEvent(span.id, 'error', {
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
+                tracer.setAttribute(span.id, 'error', true);
+                throw error;
+            }
+            finally {
+                // End span and add it to trace
+                const completedSpan = tracer.endSpan(span.id);
+                if (completedSpan) {
+                    vision.getTraceStore().addSpan(trace.id, completedSpan);
+                }
+                // Complete trace
+                const duration = Date.now() - startTime;
+                vision.completeTrace(trace.id, c.res.status, duration);
+                // Add trace ID to response headers so client can correlate metrics
+                c.header('X-Vision-Trace-Id', trace.id);
+                // Emit completion log (if enabled)
+                if (logging) {
+                    const { endpoint } = resolveEndpointTemplate(c.req.method, c.req.path);
+                    console.info(`INF request completed code=${c.res.status} duration=${duration}ms method=${c.req.method} endpoint=${endpoint} traceId=${trace.id}`);
+                }
+            }
+        }); // Close visionContext.run()
+    };
+}
+/**
+ * Match route path against pattern (simple glob-like matching)
+ * e.g., '/users/*' matches '/users/list', '/users/123'
+ */
+function matchPattern(path, pattern) {
+    if (pattern.endsWith('/*')) {
+        const prefix = pattern.slice(0, -2);
+        return path === prefix || path.startsWith(prefix + '/');
+    }
+    return path === pattern;
+}
+/**
+ * Group routes by services (auto or manual)
+ */
+function groupRoutesByServices(routes, servicesConfig) {
+    const groups = {};
+    // Manual grouping if config provided
+    if (servicesConfig && servicesConfig.length > 0) {
+        // Initialize groups from config
+        servicesConfig.forEach((svc) => {
+            groups[svc.name] = { name: svc.name, description: svc.description, routes: [] };
+        });
+        // Uncategorized group
+        groups['__uncategorized'] = { name: 'Uncategorized', routes: [] };
+        // Assign routes to services
+        routes.forEach((route) => {
+            let matched = false;
+            for (const svc of servicesConfig) {
+                if (svc.routes.some((pattern) => matchPattern(route.path, pattern))) {
+                    groups[svc.name].routes.push(route);
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                groups['__uncategorized'].routes.push(route);
+            }
+        });
+        // Remove empty uncategorized
+        if (groups['__uncategorized'].routes.length === 0) {
+            delete groups['__uncategorized'];
+        }
+    }
+    else {
+        // Auto-grouping: group by first path segment
+        // If a resource has any subpaths, all its routes go to that service
+        // First pass: collect all routes by first segment
+        const routesBySegment = new Map();
+        for (const route of routes) {
+            const segments = route.path.split('/').filter(Boolean);
+            const serviceName = segments.length > 0 ? segments[0] : 'root';
+            if (!routesBySegment.has(serviceName)) {
+                routesBySegment.set(serviceName, []);
+            }
+            routesBySegment.get(serviceName).push(route);
+        }
+        // Second pass: if a service has any multi-segment routes, keep it as a service
+        // Otherwise move single-segment routes to Root
+        groups['root'] = { name: 'Root', routes: [] };
+        for (const [serviceName, serviceRoutes] of routesBySegment) {
+            const hasMultiSegment = serviceRoutes.some(r => r.path.split('/').filter(Boolean).length > 1);
+            if (hasMultiSegment || serviceName === 'root') {
+                // This is a real service with subpaths, or it's root
+                const capitalizedName = serviceName === 'root' ? 'Root' : serviceName.charAt(0).toUpperCase() + serviceName.slice(1);
+                if (serviceName === 'root') {
+                    groups['root'].routes.push(...serviceRoutes);
+                }
+                else {
+                    groups[serviceName] = { name: capitalizedName, routes: serviceRoutes };
+                }
+            }
+            else {
+                // Single-segment route with no siblings → goes to Root
+                groups['root'].routes.push(...serviceRoutes);
+            }
+        }
+        // Remove Root if empty
+        if (groups['root'].routes.length === 0) {
+            delete groups['root'];
+        }
+    }
+    return groups;
+}
+/**
+ * Enable auto-discovery of routes (experimental)
+ * Patches Hono app methods to automatically register routes
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ * app.use('*', visionAdapter())
+ * enableAutoDiscovery(app)
+ *
+ * // Routes defined after this will be auto-discovered
+ * app.get('/hello', (c) => c.json({ hello: 'world' }))
+ * ```
+ */
+export function enableAutoDiscovery(app, options) {
+    patchHonoApp(app, options);
+    scheduleRegistration(options);
+}
+/**
+ * Get the Vision instance (for advanced usage)
+ */
+export function getVisionInstance() {
+    return visionInstance;
+}
+// Re-export monkey-patched zValidator that stores schema for Vision introspection
+// Use this instead of @hono/zod-validator to enable automatic schema detection
+export { zValidator } from './zod-validator';

package/dist/zod-validator.d.ts

@@ -0,0 +1,15 @@
+import type { ZodType } from 'zod';
+/**
+ * Monkey-patch zValidator to attach schema for Vision introspection
+ */
+export declare const zValidator: <T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> | import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>, Target extends keyof import("hono").ValidationTargets, E extends import("hono").Env, P extends string, In = T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").input<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").input<T> : never, Out = T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").output<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").infer<T> : never, I extends import("hono").Input = {
+    in: (undefined extends In ? true : false) extends true ? { [K in Target]?: In extends import("hono").ValidationTargets[K] ? In : { [K2 in keyof In]?: In[K2] extends import("hono").ValidationTargets[K][K2] ? In[K2] : import("hono").ValidationTargets[K][K2]; }; } : { [K in Target]: In extends import("hono").ValidationTargets[K] ? In : { [K2 in keyof In]: In[K2] extends import("hono").ValidationTargets[K][K2] ? In[K2] : import("hono").ValidationTargets[K][K2]; }; };
+    out: { [K in Target]: Out; };
+}, V extends I = I, InferredValue = T extends import("zod/v3").ZodType<any, import("zod/v3").ZodTypeDef, any> ? import("zod/v3").TypeOf<T> : T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").infer<T> : never>(target: Target, schema: T, hook?: import("@hono/zod-validator").Hook<InferredValue, E, P, Target, {}, T>, options?: {
+    validationFunction: (schema: T, value: import("hono").ValidationTargets[Target]) => (T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").ZodSafeParseResult<any> : import("zod/v3").SafeParseReturnType<any, any>) | Promise<T extends import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> ? import("zod").ZodSafeParseResult<any> : import("zod/v3").SafeParseReturnType<any, any>>;
+}) => import("hono").MiddlewareHandler<E, P, V>;
+/**
+ * Extract schema from validator middleware
+ */
+export declare function extractSchema(validator: any): ZodType | undefined;
+//# sourceMappingURL=zod-validator.d.ts.map

package/dist/zod-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-validator.d.ts","sourceRoot":"","sources":["../src/zod-validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAElC;;GAEG;AACH,eAAO,MAAM,UAAU;4EAqBgrB,CAAC,0EAA2D,CAAC,iBAAgB,mCAAqB,gBAAe,mCAAqB,uHAAuG,mCAAqB,gBAAe,mCAAqB;;;;+CAR3+B,CAAA;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,GAAG,GAAG,OAAO,GAAG,SAAS,CAEjE"}

package/dist/zod-validator.js

@@ -0,0 +1,23 @@
+import { zValidator as originalZValidator } from '@hono/zod-validator';
+/**
+ * Monkey-patch zValidator to attach schema for Vision introspection
+ */
+export const zValidator = new Proxy(originalZValidator, {
+    apply(target, thisArg, args) {
+        // Call original zValidator
+        const validator = Reflect.apply(target, thisArg, args);
+        // Attach schema (2nd argument) to the returned middleware handler
+        const schema = args[1];
+        if (schema && typeof schema === 'object' && '_def' in schema) {
+            ;
+            validator.__visionSchema = schema;
+        }
+        return validator;
+    }
+});
+/**
+ * Extract schema from validator middleware
+ */
+export function extractSchema(validator) {
+    return validator?.__visionSchema;
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@getvision/adapter-hono",
+  "version": "0.0.0-develop-20251031183955",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc",
+    "lint": "eslint . --max-warnings 0"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@hono/zod-validator": "^0.7.3",
+    "@getvision/core": "0.0.1",
+    "zod": "^4.1.11"
+  },
+  "peerDependencies": {
+    "hono": "^4.0.0"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "0.0.0",
+    "@repo/typescript-config": "0.0.0",
+    "@types/node": "^20.14.9",
+    "hono": "^4.6.14",
+    "typescript": "5.9.3"
+  },
+  "config": {}
+}

package/src/index.ts

@@ -0,0 +1,561 @@
+import type { Context, MiddlewareHandler } from 'hono'
+import {
+  VisionCore,
+  generateZodTemplate,
+  autoDetectPackageInfo,
+  autoDetectIntegrations,
+  detectDrizzle,
+  startDrizzleStudio,
+  stopDrizzleStudio,
+} from '@getvision/core'
+import type { RouteMetadata, VisionHonoOptions, ServiceDefinition } from '@getvision/core'
+import { existsSync } from 'fs'
+import { AsyncLocalStorage } from 'async_hooks'
+import { extractSchema } from './zod-validator'
+
+// Context storage for vision and traceId
+interface VisionContext {
+  vision: VisionCore
+  traceId: string
+}
+
+const visionContext = new AsyncLocalStorage<VisionContext>()
+
+/**
+ * Get current vision context (vision instance and traceId)
+ * Available in route handlers when using visionAdapter
+ * 
+ * @example
+ * ```ts
+ * app.get('/users', async (c) => {
+ *   const { vision, traceId } = getVisionContext()
+ *   const withSpan = vision.createSpanHelper(traceId)
+ *   // ...
+ * })
+ * ```
+ */
+export function getVisionContext(): VisionContext {
+  const context = visionContext.getStore()
+  if (!context) {
+    throw new Error('Vision context not available. Make sure visionAdapter middleware is enabled.')
+  }
+  return context
+}
+
+/**
+ * Create span helper using current trace context
+ * Shorthand for: getVisionContext() + vision.createSpanHelper()
+ * 
+ * @example
+ * ```ts
+ * app.get('/users', async (c) => {
+ *   const withSpan = useVisionSpan()
+ *   
+ *   const users = withSpan('db.select', { 'db.table': 'users' }, () => {
+ *     return db.select().from(users).all()
+ *   })
+ * })
+ * ```
+ */
+export function useVisionSpan() {
+  const { vision, traceId } = getVisionContext()
+  return vision.createSpanHelper(traceId)
+}
+
+
+/**
+ * Hono adapter for Vision Dashboard
+ * 
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { visionAdapter } from '@vision/adapter-hono'
+ * 
+ * const app = new Hono()
+ * 
+ * if (process.env.NODE_ENV === 'development') {
+ *   app.use('*', visionAdapter({ port: 9500 }))
+ * }
+ * ```
+ */
+// Global Vision instance to share across middleware
+let visionInstance: VisionCore | null = null
+const discoveredRoutes: RouteMetadata[] = []
+let registerTimer: NodeJS.Timeout | null = null
+
+function scheduleRegistration(options?: { services?: ServiceDefinition[] }) {
+  if (!visionInstance) return
+  if (registerTimer) clearTimeout(registerTimer)
+  registerTimer = setTimeout(() => {
+    if (!visionInstance || discoveredRoutes.length === 0) return
+    visionInstance.registerRoutes(discoveredRoutes)
+    const grouped = groupRoutesByServices(discoveredRoutes, options?.services)
+    const services = Object.values(grouped)
+    visionInstance.registerServices(services)
+    console.log(`📋 Auto-discovered ${discoveredRoutes.length} routes (${services.length} services)`)
+  }, 100)
+}
+
+
+/**
+ * Auto-discover routes by patching Hono app methods
+ */
+function patchHonoApp(app: any, options?: { services?: ServiceDefinition[] }) {
+  const methods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head']
+  
+  methods.forEach(method => {
+    const original = app[method]
+    if (original) {
+      app[method] = function(path: string, ...handlers: any[]) {
+        // Try to extract Zod schema from zValidator middleware
+        let requestBodySchema = undefined
+        
+        for (const handler of handlers) {
+          const schema = extractSchema(handler)
+          if (schema) {
+            requestBodySchema = generateZodTemplate(schema)
+            break
+          }
+        }
+        
+        // Register route with Vision
+        discoveredRoutes.push({
+          method: method.toUpperCase(),
+          path,
+          handler: handlers[handlers.length - 1]?.name || 'anonymous',
+          middleware: [],
+          requestBody: requestBodySchema,
+        })
+        
+        // Call original method
+        const result = original.call(this, path, ...handlers)
+        scheduleRegistration(options)
+        return result
+      }
+    }
+  })
+
+  // Patch routing of child apps to capture their routes with base prefix
+  const originalRoute = app.route
+  if (originalRoute && typeof originalRoute === 'function') {
+    app.route = function(base: string, child: any) {
+      // Attempt to read child routes and register them with base prefix
+      try {
+        const routes = (child as any)?.routes
+        if (Array.isArray(routes)) {
+          for (const r of routes) {
+            const method = (r?.method || r?.methods?.[0] || '').toString().toUpperCase() || 'GET'
+            const rawPath = r?.path || r?.pattern?.path || r?.pattern || '/'
+            const childPath = typeof rawPath === 'string' ? rawPath : '/'
+            const normalizedBase = base.endsWith('/') ? base.slice(0, -1) : base
+            const normalizedChild = childPath === '/' ? '' : (childPath.startsWith('/') ? childPath : `/${childPath}`)
+            const fullPath = `${normalizedBase}${normalizedChild}` || '/'
+            discoveredRoutes.push({
+              method,
+              path: fullPath,
+              handler: r?.handler?.name || 'anonymous',
+              middleware: [],
+            })
+          }
+          scheduleRegistration(options)
+        }
+      } catch {}
+      return originalRoute.call(this, base, child)
+    }
+  }
+}
+
+/**
+ * Resolve endpoint template (e.g. /users/:id) for a concrete path
+ */
+function resolveEndpointTemplate(method: string, concretePath: string): { endpoint: string; handler: string } {
+  const candidates = discoveredRoutes.filter((r) => r.method === method.toUpperCase())
+  for (const r of candidates) {
+    const pattern = '^' + r.path.replace(/:[^/]+/g, '[^/]+') + '$'
+    const re = new RegExp(pattern)
+    if (re.test(concretePath)) {
+      return { endpoint: r.path, handler: r.handler || 'anonymous' }
+    }
+  }
+  return { endpoint: concretePath, handler: 'anonymous' }
+}
+
+/**
+ * Extract params by comparing template path with concrete path
+ * e.g. template=/users/:id, concrete=/users/123 => { id: '123' }
+ */
+function extractParams(template: string, concrete: string): Record<string, string> | undefined {
+  const tParts = template.split('/').filter(Boolean)
+  const cParts = concrete.split('/').filter(Boolean)
+  if (tParts.length !== cParts.length) return undefined
+  const result: Record<string, string> = {}
+  tParts.forEach((seg, i) => {
+    if (seg.startsWith(':')) {
+      result[seg.slice(1)] = cParts[i]
+    }
+  })
+  return Object.keys(result).length ? result : undefined
+}
+
+export function visionAdapter(options: VisionHonoOptions = {}): MiddlewareHandler {
+  const { enabled = true, port = 9500, maxTraces = 1000, logging = true } = options
+
+  if (!enabled) {
+    return async (c, next) => await next()
+  }
+
+  // Initialize Vision Core once
+  if (!visionInstance) {
+    visionInstance = new VisionCore({ port, maxTraces })
+
+    // Auto-detect service info
+    const pkgInfo = autoDetectPackageInfo()
+    const autoIntegrations = autoDetectIntegrations()
+
+    // Merge with user-provided config
+    const serviceName = options.service?.name || options.name || pkgInfo.name
+    const serviceVersion = options.service?.version || pkgInfo.version
+    const serviceDesc = options.service?.description
+    const integrations = {
+      ...autoIntegrations,
+      ...options.service?.integrations,
+    }
+
+    // Filter out undefined values from integrations
+    const cleanIntegrations: Record<string, string> = {}
+    for (const [key, value] of Object.entries(integrations)) {
+      if (value !== undefined) {
+        cleanIntegrations[key] = value
+      }
+    }
+
+    // Detect and optionally start Drizzle Studio
+    const drizzleInfo = detectDrizzle()
+    let drizzleStudioUrl: string | undefined
+    
+    if (drizzleInfo.detected) {
+      console.log(`🗄️  Drizzle detected (${drizzleInfo.configPath})`)
+      
+      if (options.drizzle?.autoStart) {
+        const drizzlePort = options.drizzle.port || 4983
+        const started = startDrizzleStudio(drizzlePort)
+        if (started) {
+          // Drizzle Studio uses local.drizzle.studio domain (with HTTPS)
+          drizzleStudioUrl = 'https://local.drizzle.studio'
+        }
+      } else {
+        console.log('💡 Tip: Enable Drizzle Studio auto-start with drizzle: { autoStart: true }')
+        drizzleStudioUrl = 'https://local.drizzle.studio'
+      }
+    }
+
+    // Set app status with service metadata
+    visionInstance.setAppStatus({
+      name: serviceName,
+      version: serviceVersion,
+      description: serviceDesc,
+      running: true,
+      pid: process.pid,
+      metadata: {
+        framework: 'hono',
+        integrations: Object.keys(cleanIntegrations).length > 0 ? cleanIntegrations : undefined,
+        drizzle: drizzleInfo.detected
+          ? {
+              detected: true,
+              configPath: drizzleInfo.configPath,
+              studioUrl: drizzleStudioUrl,
+              autoStarted: options.drizzle?.autoStart || false,
+            }
+          : undefined,
+      },
+    })
+
+    // Cleanup on exit
+    process.on('SIGINT', () => {
+      stopDrizzleStudio()
+      process.exit(0)
+    })
+
+    process.on('SIGTERM', () => {
+      stopDrizzleStudio()
+      process.exit(0)
+    })
+  }
+
+  const vision = visionInstance
+
+  // Middleware to trace requests
+  return async (c: Context, next) => {
+    // Skip tracing for OPTIONS requests (CORS preflight)
+    if (c.req.method === 'OPTIONS') {
+      return next()
+    }
+
+    const startTime = Date.now()
+    
+    // Create trace
+    const trace = vision.createTrace(c.req.method, c.req.path)
+    
+    // Run request in AsyncLocalStorage context
+    return visionContext.run({ vision, traceId: trace.id }, async () => {
+      // Also add to Hono context for compatibility
+      c.set('vision', vision)
+      c.set('traceId', trace.id)
+      
+      // Start main span
+      const tracer = vision.getTracer()
+      const span = tracer.startSpan('http.request', trace.id)
+    
+    // Add request attributes
+    tracer.setAttribute(span.id, 'http.method', c.req.method)
+    tracer.setAttribute(span.id, 'http.path', c.req.path)
+    tracer.setAttribute(span.id, 'http.url', c.req.url)
+    
+    // Add query params if any
+    const url = new URL(c.req.url)
+    if (url.search) {
+      tracer.setAttribute(span.id, 'http.query', url.search)
+    }
+
+    // Capture request metadata (headers, query, body if json)
+    try {
+      const rawReq = c.req.raw
+      const headers: Record<string, string> = {}
+      rawReq.headers.forEach((v, k) => { headers[k] = v })
+      const urlObj = new URL(c.req.url)
+      const query: Record<string, string> = {}
+      urlObj.searchParams.forEach((v, k) => { query[k] = v })
+
+      let body: unknown = undefined
+      const ct = headers['content-type'] || headers['Content-Type']
+      if (ct && ct.includes('application/json')) {
+        try {
+          body = await rawReq.clone().json()
+        } catch {}
+      }
+
+      const sessionId = headers['x-vision-session']
+      if (sessionId) {
+        tracer.setAttribute(span.id, 'session.id', sessionId)
+        trace.metadata = { ...(trace.metadata || {}), sessionId }
+      }
+
+      const requestMeta = {
+        method: c.req.method,
+        url: urlObj.pathname + (urlObj.search || ''),
+        headers,
+        query: Object.keys(query).length ? query : undefined,
+        body,
+      }
+      tracer.setAttribute(span.id, 'http.request', requestMeta)
+      // Also mirror to trace-level metadata for convenience
+      trace.metadata = { ...(trace.metadata || {}), request: requestMeta }
+
+      // Emit start log (if enabled)
+      if (logging) {
+        const { endpoint, handler } = resolveEndpointTemplate(c.req.method, c.req.path)
+        const params = extractParams(endpoint, c.req.path)
+        const parts = [
+          `method=${c.req.method}`,
+          `endpoint=${endpoint}`,
+          `service=${handler}`,
+        ]
+        if (params) parts.push(`params=${JSON.stringify(params)}`)
+        if (Object.keys(query).length) parts.push(`query=${JSON.stringify(query)}`)
+        if ((trace.metadata as any)?.sessionId) parts.push(`sessionId=${(trace.metadata as any).sessionId}`)
+        parts.push(`traceId=${trace.id}`)
+        console.info(`INF starting request ${parts.join(' ')}`)
+      }
+
+      // Execute request
+      await next()
+      
+      // Add response attributes
+      tracer.setAttribute(span.id, 'http.status_code', c.res.status)
+      const resHeaders: Record<string, string> = {}
+      c.res.headers?.forEach((v, k) => { resHeaders[k] = v as unknown as string })
+
+      let respBody: unknown = undefined
+      const resCt = c.res.headers?.get('content-type') || ''
+      try {
+        const clone = c.res.clone()
+        if (resCt.includes('application/json')) {
+          const txt = await clone.text()
+          if (txt && txt.length <= 65536) {
+            try { respBody = JSON.parse(txt) } catch { respBody = txt }
+          }
+        }
+      } catch {}
+
+      const responseMeta = {
+        status: c.res.status,
+        headers: Object.keys(resHeaders).length ? resHeaders : undefined,
+        body: respBody,
+      }
+      tracer.setAttribute(span.id, 'http.response', responseMeta)
+      trace.metadata = { ...(trace.metadata || {}), response: responseMeta }
+      
+    } catch (error) {
+      // Track error
+      tracer.addEvent(span.id, 'error', {
+        message: error instanceof Error ? error.message : 'Unknown error',
+        stack: error instanceof Error ? error.stack : undefined,
+      })
+      
+      tracer.setAttribute(span.id, 'error', true)
+      throw error
+      
+    } finally {
+      // End span and add it to trace
+      const completedSpan = tracer.endSpan(span.id)
+      if (completedSpan) {
+        vision.getTraceStore().addSpan(trace.id, completedSpan)
+      }
+      
+      // Complete trace
+      const duration = Date.now() - startTime
+      vision.completeTrace(trace.id, c.res.status, duration)
+      
+      // Add trace ID to response headers so client can correlate metrics
+      c.header('X-Vision-Trace-Id', trace.id)
+
+      // Emit completion log (if enabled)
+      if (logging) {
+        const { endpoint } = resolveEndpointTemplate(c.req.method, c.req.path)
+        console.info(
+          `INF request completed code=${c.res.status} duration=${duration}ms method=${c.req.method} endpoint=${endpoint} traceId=${trace.id}`
+        )
+      }
+    }
+    }) // Close visionContext.run()
+  }
+}
+
+
+/**
+ * Match route path against pattern (simple glob-like matching)
+ * e.g., '/users/*' matches '/users/list', '/users/123'
+ */
+function matchPattern(path: string, pattern: string): boolean {
+  if (pattern.endsWith('/*')) {
+    const prefix = pattern.slice(0, -2)
+    return path === prefix || path.startsWith(prefix + '/')
+  }
+  return path === pattern
+}
+
+/**
+ * Group routes by services (auto or manual)
+ */
+function groupRoutesByServices(
+  routes: RouteMetadata[],
+  servicesConfig?: ServiceDefinition[]
+): Record<string, { name: string; description?: string; routes: RouteMetadata[] }> {
+  const groups: Record<string, { name: string; description?: string; routes: RouteMetadata[] }> = {}
+
+  // Manual grouping if config provided
+  if (servicesConfig && servicesConfig.length > 0) {
+    // Initialize groups from config
+    servicesConfig.forEach((svc) => {
+      groups[svc.name] = { name: svc.name, description: svc.description, routes: [] }
+    })
+
+    // Uncategorized group
+    groups['__uncategorized'] = { name: 'Uncategorized', routes: [] }
+
+    // Assign routes to services
+    routes.forEach((route) => {
+      let matched = false
+      for (const svc of servicesConfig) {
+        if (svc.routes.some((pattern) => matchPattern(route.path, pattern))) {
+          groups[svc.name].routes.push(route)
+          matched = true
+          break
+        }
+      }
+      if (!matched) {
+        groups['__uncategorized'].routes.push(route)
+      }
+    })
+
+    // Remove empty uncategorized
+    if (groups['__uncategorized'].routes.length === 0) {
+      delete groups['__uncategorized']
+    }
+  } else {
+    // Auto-grouping: group by first path segment
+    // If a resource has any subpaths, all its routes go to that service
+    
+    // First pass: collect all routes by first segment
+    const routesBySegment = new Map<string, RouteMetadata[]>()
+    
+    for (const route of routes) {
+      const segments = route.path.split('/').filter(Boolean)
+      const serviceName = segments.length > 0 ? segments[0] : 'root'
+      
+      if (!routesBySegment.has(serviceName)) {
+        routesBySegment.set(serviceName, [])
+      }
+      routesBySegment.get(serviceName)!.push(route)
+    }
+    
+    // Second pass: if a service has any multi-segment routes, keep it as a service
+    // Otherwise move single-segment routes to Root
+    groups['root'] = { name: 'Root', routes: [] }
+    
+    for (const [serviceName, serviceRoutes] of routesBySegment) {
+      const hasMultiSegment = serviceRoutes.some(r => r.path.split('/').filter(Boolean).length > 1)
+      
+      if (hasMultiSegment || serviceName === 'root') {
+        // This is a real service with subpaths, or it's root
+        const capitalizedName = serviceName === 'root' ? 'Root' : serviceName.charAt(0).toUpperCase() + serviceName.slice(1)
+        
+        if (serviceName === 'root') {
+          groups['root'].routes.push(...serviceRoutes)
+        } else {
+          groups[serviceName] = { name: capitalizedName, routes: serviceRoutes }
+        }
+      } else {
+        // Single-segment route with no siblings → goes to Root
+        groups['root'].routes.push(...serviceRoutes)
+      }
+    }
+    
+    // Remove Root if empty
+    if (groups['root'].routes.length === 0) {
+      delete groups['root']
+    }
+  }
+
+  return groups
+}
+
+/**
+ * Enable auto-discovery of routes (experimental)
+ * Patches Hono app methods to automatically register routes
+ * 
+ * @example
+ * ```ts
+ * const app = new Hono()
+ * app.use('*', visionAdapter())
+ * enableAutoDiscovery(app)
+ * 
+ * // Routes defined after this will be auto-discovered
+ * app.get('/hello', (c) => c.json({ hello: 'world' }))
+ * ```
+ */
+export function enableAutoDiscovery(app: any, options?: { services?: ServiceDefinition[] }) {
+  patchHonoApp(app, options)
+  scheduleRegistration(options)
+}
+
+/**
+ * Get the Vision instance (for advanced usage)
+ */
+export function getVisionInstance(): VisionCore | null {
+  return visionInstance
+}
+
+// Re-export monkey-patched zValidator that stores schema for Vision introspection
+// Use this instead of @hono/zod-validator to enable automatic schema detection
+export { zValidator } from './zod-validator'

package/src/zod-validator.ts

@@ -0,0 +1,27 @@
+import { zValidator as originalZValidator } from '@hono/zod-validator'
+import type { ZodType } from 'zod'
+
+/**
+ * Monkey-patch zValidator to attach schema for Vision introspection
+ */
+export const zValidator = new Proxy(originalZValidator, {
+  apply(target, thisArg, args: any[]) {
+    // Call original zValidator
+    const validator = Reflect.apply(target, thisArg, args)
+    
+    // Attach schema (2nd argument) to the returned middleware handler
+    const schema = args[1]
+    if (schema && typeof schema === 'object' && '_def' in schema) {
+      ;(validator as any).__visionSchema = schema
+    }
+    
+    return validator
+  }
+})
+
+/**
+ * Extract schema from validator middleware
+ */
+export function extractSchema(validator: any): ZodType | undefined {
+  return validator?.__visionSchema
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@repo/typescript-config/base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ES2022"],
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}