@getvision/core 0.0.0 → 0.0.2-ae8b128-develop

package/dist/core.d.ts

@@ -0,0 +1,98 @@
+import { VisionWebSocketServer } from './server';
+import { TraceStore, Tracer } from './tracing';
+import { LogStore } from './logs/store';
+import type { VisionServerOptions, AppStatus, RouteMetadata, ServiceGroup, Trace, DashboardEvent, LogLevel, LogEntry } from './types/index';
+/**
+ * VisionCore - Main orchestrator for the Vision Dashboard
+ */
+export declare class VisionCore {
+    private server;
+    private traceStore;
+    private tracer;
+    private logStore;
+    private consoleInterceptor?;
+    private routes;
+    private services;
+    private appStatus;
+    constructor(options?: VisionServerOptions);
+    /**
+     * Register all JSON-RPC methods
+     */
+    private registerMethods;
+    /**
+     * Update app status
+     */
+    setAppStatus(status: Partial<AppStatus>): void;
+    /**
+     * Register routes from adapter
+     */
+    registerRoutes(routes: RouteMetadata[]): void;
+    /**
+     * Register grouped services
+     */
+    registerServices(services: ServiceGroup[]): void;
+    /**
+     * Create a new trace
+     */
+    createTrace(method: string, path: string): Trace;
+    /**
+     * Complete a trace
+     */
+    completeTrace(traceId: string, statusCode: number, duration: number): void;
+    /**
+     * Get tracer instance
+     */
+    getTracer(): Tracer;
+    /**
+     * Get WebSocket server instance (for registering JSON-RPC methods)
+     */
+    getServer(): VisionWebSocketServer;
+    /**
+     * Create a span helper for easy span creation
+     * @param traceId - Trace ID to attach spans to
+     * @returns A function that creates spans with automatic error handling
+     *
+     * @example
+     * ```ts
+     * const withSpan = vision.createSpanHelper(traceId)
+     *
+     * const user = withSpan('db.select', { 'db.system': 'sqlite' }, () => {
+     *   return db.select().from(users).get()
+     * })
+     * ```
+     */
+    createSpanHelper(traceId: string): <T>(name: string, attributes: Record<string, any> | undefined, fn: () => T) => T;
+    /**
+     * Get trace store
+     */
+    getTraceStore(): TraceStore;
+    /**
+     * Universal log API - can be called by any logger
+     */
+    log(level: LogLevel, message: string, meta?: Record<string, any>): LogEntry;
+    /**
+     * Get log store instance
+     */
+    getLogStore(): LogStore;
+    /**
+     * Broadcast event to all connected clients
+     */
+    broadcast(event: DashboardEvent): void;
+    /**
+     * Log stdout message
+     */
+    logStdout(message: string): void;
+    /**
+     * Log stderr message
+     */
+    logStderr(message: string): void;
+    /**
+     * Get number of connected dashboard clients
+     */
+    getClientCount(): number;
+    /**
+     * Close the Vision server
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC,OAAO,KAAK,EACV,mBAAmB,EACnB,SAAS,EACT,aAAa,EACb,YAAY,EACZ,KAAK,EACL,cAAc,EACd,QAAQ,EACR,QAAQ,EACT,MAAM,eAAe,CAAA;AAEtB;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAU;IAC1B,OAAO,CAAC,kBAAkB,CAAC,CAAoB;IAC/C,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,SAAS,CAKhB;gBAEW,OAAO,GAAE,mBAAwB;IAwB7C;;OAEG;IACH,OAAO,CAAC,eAAe;IA0FvB;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;IAK9C;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI;IAI7C;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIhD;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK;IAKhD;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAS1E;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,SAAS,IAAI,qBAAqB;IAIlC;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,IACtB,CAAC,EACP,MAAM,MAAM,EACZ,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAK,EACpC,IAAI,MAAM,CAAC,KACV,CAAC;IAqCN;;OAEG;IACH,aAAa,IAAI,UAAU;IAI3B;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,QAAQ;IAU3E;;OAEG;IACH,WAAW,IAAI,QAAQ;IAIvB;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAItC;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOhC;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOhC;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/core.js

@@ -0,0 +1,266 @@
+import { VisionWebSocketServer } from './server';
+import { TraceStore, Tracer } from './tracing';
+import { LogStore } from './logs/store';
+import { ConsoleInterceptor } from './logs/interceptor';
+/**
+ * VisionCore - Main orchestrator for the Vision Dashboard
+ */
+export class VisionCore {
+    server;
+    traceStore;
+    tracer;
+    logStore;
+    consoleInterceptor;
+    routes = [];
+    services = [];
+    appStatus = {
+        name: 'Unknown',
+        version: '0.0.0',
+        environment: 'development',
+        running: false,
+    };
+    constructor(options = {}) {
+        this.server = new VisionWebSocketServer(options);
+        this.traceStore = new TraceStore(options.maxTraces);
+        this.tracer = new Tracer();
+        this.logStore = new LogStore(options.maxLogs);
+        // Optional console intercept
+        if (options.captureConsole !== false) {
+            this.consoleInterceptor = new ConsoleInterceptor(this.logStore, () => {
+                // Broadcast latest log entry to connected clients
+                this.broadcast({
+                    type: 'log.entry',
+                    data: this.logStore.getLogs({ limit: 1 })[0]
+                });
+            });
+            this.consoleInterceptor.start();
+        }
+        this.registerMethods();
+    }
+    /**
+     * Register all JSON-RPC methods
+     */
+    registerMethods() {
+        // App status
+        this.server.registerMethod('status', async () => {
+            return this.appStatus;
+        });
+        // List all traces
+        this.server.registerMethod('traces/list', async (params) => {
+            return this.traceStore.getTraces({
+                method: params?.method,
+                statusCode: params?.statusCode,
+                minDuration: params?.minDuration,
+                limit: params?.limit ?? 100,
+            });
+        });
+        // Get specific trace
+        this.server.registerMethod('traces/get', async (params) => {
+            if (!params?.traceId) {
+                throw new Error('traceId is required');
+            }
+            return this.traceStore.getTrace(params.traceId);
+        });
+        // Clear traces
+        this.server.registerMethod('traces/clear', async () => {
+            this.traceStore.clear();
+            return { success: true };
+        });
+        // Export traces
+        this.server.registerMethod('traces/export', async (params) => {
+            const format = params?.format || 'json';
+            const traces = this.traceStore.getAllTraces();
+            if (format === 'ndjson') {
+                return traces.map(t => JSON.stringify(t)).join('\n');
+            }
+            return JSON.stringify(traces, null, 2);
+        });
+        // Get routes
+        this.server.registerMethod('routes/list', async () => {
+            return this.routes;
+        });
+        // Get services (grouped routes)
+        this.server.registerMethod('services/list', async () => {
+            return this.services;
+        });
+        // Get version
+        this.server.registerMethod('version', async () => {
+            return {
+                version: '0.0.1',
+                name: 'Vision Dashboard',
+            };
+        });
+        // Logs methods
+        this.server.registerMethod('logs/list', async (params) => {
+            return this.logStore.getLogs({
+                level: params?.level,
+                search: params?.search,
+                limit: params?.limit ?? 100,
+                since: params?.since,
+            });
+        });
+        this.server.registerMethod('logs/clear', async () => {
+            this.logStore.clear();
+            return { success: true };
+        });
+        this.server.registerMethod('traces/addClientMetrics', async (params) => {
+            const { traceId, clientDuration } = params;
+            if (!traceId || typeof clientDuration !== 'number') {
+                throw new Error('traceId and clientDuration are required');
+            }
+            const trace = this.traceStore.getTrace(traceId);
+            if (trace) {
+                trace.metadata = { ...(trace.metadata || {}), clientDuration };
+            }
+            return { success: true };
+        });
+    }
+    /**
+     * Update app status
+     */
+    setAppStatus(status) {
+        this.appStatus = { ...this.appStatus, ...status };
+        this.broadcast({ type: 'app.started', data: this.appStatus });
+    }
+    /**
+     * Register routes from adapter
+     */
+    registerRoutes(routes) {
+        this.routes = routes;
+    }
+    /**
+     * Register grouped services
+     */
+    registerServices(services) {
+        this.services = services;
+    }
+    /**
+     * Create a new trace
+     */
+    createTrace(method, path) {
+        const trace = this.traceStore.createTrace(method, path);
+        return trace;
+    }
+    /**
+     * Complete a trace
+     */
+    completeTrace(traceId, statusCode, duration) {
+        this.traceStore.completeTrace(traceId, statusCode, duration);
+        const trace = this.traceStore.getTrace(traceId);
+        if (trace) {
+            this.broadcast({ type: 'trace.new', data: trace });
+        }
+    }
+    /**
+     * Get tracer instance
+     */
+    getTracer() {
+        return this.tracer;
+    }
+    /**
+     * Get WebSocket server instance (for registering JSON-RPC methods)
+     */
+    getServer() {
+        return this.server;
+    }
+    /**
+     * Create a span helper for easy span creation
+     * @param traceId - Trace ID to attach spans to
+     * @returns A function that creates spans with automatic error handling
+     *
+     * @example
+     * ```ts
+     * const withSpan = vision.createSpanHelper(traceId)
+     *
+     * const user = withSpan('db.select', { 'db.system': 'sqlite' }, () => {
+     *   return db.select().from(users).get()
+     * })
+     * ```
+     */
+    createSpanHelper(traceId) {
+        return (name, attributes = {}, fn) => {
+            const span = this.tracer.startSpan(name, traceId);
+            // Add attributes
+            for (const [key, value] of Object.entries(attributes)) {
+                this.tracer.setAttribute(span.id, key, value);
+            }
+            try {
+                const result = fn();
+                const completedSpan = this.tracer.endSpan(span.id);
+                // Add span to trace store
+                if (completedSpan) {
+                    this.traceStore.addSpan(traceId, completedSpan);
+                }
+                return result;
+            }
+            catch (error) {
+                this.tracer.setAttribute(span.id, 'error', true);
+                this.tracer.setAttribute(span.id, 'error.message', error instanceof Error ? error.message : String(error));
+                const completedSpan = this.tracer.endSpan(span.id);
+                // Add span to trace store even on error
+                if (completedSpan) {
+                    this.traceStore.addSpan(traceId, completedSpan);
+                }
+                throw error;
+            }
+        };
+    }
+    /**
+     * Get trace store
+     */
+    getTraceStore() {
+        return this.traceStore;
+    }
+    /**
+     * Universal log API - can be called by any logger
+     */
+    log(level, message, meta) {
+        const args = meta ? [meta] : undefined;
+        const entry = this.logStore.addLog(level, message, args);
+        // Broadcast to connected clients
+        this.broadcast({ type: 'log.entry', data: entry });
+        return entry;
+    }
+    /**
+     * Get log store instance
+     */
+    getLogStore() {
+        return this.logStore;
+    }
+    /**
+     * Broadcast event to all connected clients
+     */
+    broadcast(event) {
+        this.server.broadcast(event);
+    }
+    /**
+     * Log stdout message
+     */
+    logStdout(message) {
+        this.broadcast({
+            type: 'log.stdout',
+            data: { message, timestamp: Date.now() },
+        });
+    }
+    /**
+     * Log stderr message
+     */
+    logStderr(message) {
+        this.broadcast({
+            type: 'log.stderr',
+            data: { message, timestamp: Date.now() },
+        });
+    }
+    /**
+     * Get number of connected dashboard clients
+     */
+    getClientCount() {
+        return this.server.getClientCount();
+    }
+    /**
+     * Close the Vision server
+     */
+    async close() {
+        await this.server.close();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { VisionCore } from './core';
+export { VisionWebSocketServer } from './server/index';
+export { TraceStore, Tracer } from './tracing/index';
+export { generateZodTemplate } from './utils/zod-utils';
+export { autoDetectPackageInfo, autoDetectIntegrations, detectDrizzle, startDrizzleStudio, stopDrizzleStudio, } from './utils/service-detection';
+export type { PackageInfo, IntegrationConfig, DrizzleInfo } from './utils/service-detection';
+export type * from './types/index';
+//# 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,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,2BAA2B,CAAA;AAClC,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAC5F,mBAAmB,eAAe,CAAA"}