@olane/o-node 0.7.12-alpha.4 → 0.7.12-alpha.41

package/dist/o-node/src/streaming/node-stream-handler.js

@@ -0,0 +1,101 @@
+import { StreamHandlerBase, ProtocolBuilder, } from '../../../o-core/src/streaming/index.js';
+/**
+ * o-node specific implementation of StreamHandlerBase.
+ * Integrates with libp2p streams and tracks metrics for o-node tools.
+ */
+export class NodeStreamHandler extends StreamHandlerBase {
+    constructor(transport, options = {}) {
+        super(options);
+        this.successCount = 0;
+        this.errorCount = 0;
+        this.transport = transport;
+        this.nodeOptions = {
+            trackSuccessCount: true,
+            trackErrorCount: true,
+            ...options,
+        };
+    }
+    /**
+     * Get the success count (number of chunks successfully sent)
+     */
+    getSuccessCount() {
+        return this.successCount;
+    }
+    /**
+     * Get the error count
+     */
+    getErrorCount() {
+        return this.errorCount;
+    }
+    /**
+     * Reset metrics
+     */
+    resetMetrics() {
+        this.successCount = 0;
+        this.errorCount = 0;
+    }
+    /**
+     * Implementation of sendChunk using libp2p transport and protocol builder
+     */
+    async sendChunk(chunk, sequence, isLast, request) {
+        // Build the JSON-RPC streaming chunk message
+        const message = ProtocolBuilder.buildStreamChunkFromRequest(chunk, sequence, isLast, request);
+        // Encode the message to bytes
+        const encoded = ProtocolBuilder.encodeMessage(message);
+        // Send through the transport (handles backpressure)
+        await this.transport.send(encoded);
+        // Track metrics if enabled
+        if (this.nodeOptions.trackSuccessCount) {
+            this.successCount++;
+        }
+        // Close the stream if this is the last chunk
+        if (isLast) {
+            await this.transport.close();
+        }
+    }
+    /**
+     * Hook: Called when streaming starts
+     */
+    onStreamStart(request) {
+        // Reset metrics for this stream
+        if (this.nodeOptions.enableMetrics) {
+            this.resetMetrics();
+        }
+    }
+    /**
+     * Hook: Called when streaming completes successfully
+     */
+    onStreamComplete(request, totalChunks) {
+        // Log completion if metrics enabled
+        if (this.nodeOptions.enableMetrics) {
+            console.log(`Stream completed for ${request.method}: ${totalChunks} chunks sent`);
+        }
+    }
+    /**
+     * Hook: Called when streaming encounters an error
+     */
+    onStreamError(request, error) {
+        // Track error count
+        if (this.nodeOptions.trackErrorCount) {
+            this.errorCount++;
+        }
+        // Log error
+        console.error(`Stream error for ${request.method}:`, error);
+    }
+    /**
+     * Reset the handler for reuse with a new transport
+     */
+    reset() {
+        // Call parent reset
+        this.state = 0; // Reset state (IDLE)
+        this.currentSequence = 0;
+        this.resetMetrics();
+    }
+    /**
+     * Create a new NodeStreamHandler with a different transport
+     * (useful for handling multiple streams)
+     */
+    static create(transport, options) {
+        return new NodeStreamHandler(transport, options);
+    }
+}

package/dist/o-node/src/ui/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './ui-graph.manager';
+//# sourceMappingURL=index.d.ts.map

package/dist/o-node/src/ui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC"}

package/dist/o-node/src/ui/index.js

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './ui-graph.manager';

package/dist/o-node/src/ui/types.d.ts

@@ -0,0 +1,110 @@
+import { oAddress } from '../../../o-core/src';
+/**
+ * UI component node types
+ */
+export declare enum UINodeType {
+    SCREEN = "screen",
+    BUTTON = "button",
+    INPUT = "input",
+    TEXT = "text",
+    VIEW = "view",
+    MODAL = "modal",
+    BOTTOM_SHEET = "bottom_sheet",
+    FORM = "form",
+    LIST = "list",
+    LIST_ITEM = "list_item",
+    CUSTOM = "custom"
+}
+/**
+ * Represents a virtual UI component node in the graph
+ */
+export interface ComponentNode {
+    /** Unique identifier for the component */
+    id: string;
+    /** Component type (button, input, screen, etc.) */
+    type: UINodeType | string;
+    /** Component's address in the Olane graph */
+    address: oAddress;
+    /** Component props/configuration */
+    props: Record<string, any>;
+    /** Component internal state */
+    state: Record<string, any>;
+    /** Parent component ID (null for root screens) */
+    parentId: string | null;
+    /** Array of child component IDs */
+    childIds: string[];
+    /** Available tool methods for this component */
+    methods: string[];
+    /** Timestamp when registered */
+    registeredAt: number;
+    /** Last update timestamp */
+    updatedAt: number;
+    /** Component metadata */
+    metadata?: {
+        screenName?: string;
+        routePath?: string;
+        visible?: boolean;
+        disabled?: boolean;
+        [key: string]: any;
+    };
+}
+/**
+ * Request to register a component
+ */
+export interface RegisterComponentRequest {
+    id: string;
+    type: UINodeType | string;
+    address: string;
+    props?: Record<string, any>;
+    state?: Record<string, any>;
+    parentId?: string | null;
+    methods?: string[];
+    metadata?: Record<string, any>;
+}
+/**
+ * Response from component registration
+ */
+export interface RegisterComponentResponse {
+    success: boolean;
+    nodeId: string;
+    address: string;
+    message?: string;
+}
+/**
+ * Request to update component
+ */
+export interface UpdateComponentRequest {
+    nodeId: string;
+    props?: Record<string, any>;
+    state?: Record<string, any>;
+    metadata?: Record<string, any>;
+}
+/**
+ * Request to invoke component action
+ */
+export interface InvokeActionRequest {
+    nodeId: string;
+    method: string;
+    params?: any;
+}
+/**
+ * Response from component query
+ */
+export interface QueryHierarchyResponse {
+    node: ComponentNode;
+    children: ComponentNode[];
+    parent: ComponentNode | null;
+}
+/**
+ * Component method handler
+ */
+export type ComponentMethodHandler = (params?: any) => Promise<any> | any;
+/**
+ * Component method registry
+ */
+export interface ComponentMethodRegistry {
+    [nodeId: string]: {
+        [method: string]: ComponentMethodHandler;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/o-node/src/ui/types.d.ts.map

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

package/dist/o-node/src/ui/types.js

@@ -0,0 +1,17 @@
+/**
+ * UI component node types
+ */
+export var UINodeType;
+(function (UINodeType) {
+    UINodeType["SCREEN"] = "screen";
+    UINodeType["BUTTON"] = "button";
+    UINodeType["INPUT"] = "input";
+    UINodeType["TEXT"] = "text";
+    UINodeType["VIEW"] = "view";
+    UINodeType["MODAL"] = "modal";
+    UINodeType["BOTTOM_SHEET"] = "bottom_sheet";
+    UINodeType["FORM"] = "form";
+    UINodeType["LIST"] = "list";
+    UINodeType["LIST_ITEM"] = "list_item";
+    UINodeType["CUSTOM"] = "custom";
+})(UINodeType || (UINodeType = {}));

package/dist/o-node/src/ui/ui-graph.manager.d.ts

@@ -0,0 +1,70 @@
+import { oNodeTool } from '../o-node.tool';
+import { oRequest } from '../../../o-core/src';
+import { ComponentNode, RegisterComponentResponse, QueryHierarchyResponse } from './types';
+/**
+ * UIGraphManager manages the hierarchical graph of UI components
+ * Acts as a centralized registry for all UI elements in the application
+ */
+export declare class UIGraphManager extends oNodeTool {
+    private componentRegistry;
+    private methodHandlers;
+    /**
+     * Register a new UI component in the graph
+     */
+    _tool_register_component(request: oRequest): Promise<RegisterComponentResponse>;
+    /**
+     * Unregister a UI component from the graph
+     */
+    _tool_unregister_component(request: oRequest): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Update component props, state, or metadata
+     */
+    _tool_update_component(request: oRequest): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Invoke a method on a component
+     */
+    _tool_invoke_action(request: oRequest): Promise<any>;
+    /**
+     * Query component hierarchy
+     */
+    _tool_query_hierarchy(request: oRequest): Promise<QueryHierarchyResponse>;
+    /**
+     * Get all registered components (for debugging)
+     */
+    _tool_list_components(request: oRequest): Promise<{
+        components: ComponentNode[];
+        count: number;
+    }>;
+    /**
+     * Get component tree structure
+     */
+    _tool_get_tree(request: oRequest): Promise<any>;
+    /**
+     * Register a method handler for a component
+     * This is called from the client side to register callbacks
+     */
+    registerMethodHandler(nodeId: string, method: string, handler: (params?: any) => Promise<any> | any): void;
+    /**
+     * Unregister all method handlers for a component
+     */
+    unregisterMethodHandlers(nodeId: string): void;
+    /**
+     * Get component by ID
+     */
+    getComponent(nodeId: string): ComponentNode | undefined;
+    /**
+     * Get all children of a component
+     */
+    getComponentChildren(nodeId: string): ComponentNode[];
+    /**
+     * Get parent of a component
+     */
+    getParent(nodeId: string): ComponentNode | null;
+}
+//# sourceMappingURL=ui-graph.manager.d.ts.map

package/dist/o-node/src/ui/ui-graph.manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-graph.manager.d.ts","sourceRoot":"","sources":["../../../../src/ui/ui-graph.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C,OAAO,EACL,aAAa,EAEb,yBAAyB,EAGzB,sBAAsB,EAEvB,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC3C,OAAO,CAAC,iBAAiB,CAAyC;IAClE,OAAO,CAAC,cAAc,CAA+B;IAErD;;OAEG;IACG,wBAAwB,CAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,yBAAyB,CAAC;IA8ErC;;OAEG;IACG,0BAA0B,CAC9B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAiDjD;;OAEG;IACG,sBAAsB,CAC1B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAqCjD;;OAEG;IACG,mBAAmB,CACvB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,GAAG,CAAC;IAiCf;;OAEG;IACG,qBAAqB,CACzB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,sBAAsB,CAAC;IAyBlC;;OAEG;IACG,qBAAqB,CACzB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC;QAAE,UAAU,EAAE,aAAa,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAS1D;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA2BrD;;;OAGG;IACI,qBAAqB,CAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,GAC5C,IAAI;IAQP;;OAEG;IACI,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAKrD;;OAEG;IACI,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI9D;;OAEG;IACI,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE;IAS5D;;OAEG;IACI,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;CAMvD"}

package/dist/o-node/src/ui/ui-graph.manager.js

@@ -0,0 +1,274 @@
+import { oNodeTool } from '../o-node.tool';
+import { oRequest } from '../../../o-core/src';
+import { oAddress } from '../../../o-core/src';
+/**
+ * UIGraphManager manages the hierarchical graph of UI components
+ * Acts as a centralized registry for all UI elements in the application
+ */
+export class UIGraphManager extends oNodeTool {
+    constructor() {
+        super(...arguments);
+        this.componentRegistry = new Map();
+        this.methodHandlers = {};
+    }
+    /**
+     * Register a new UI component in the graph
+     */
+    async _tool_register_component(request) {
+        const { id, type, address, props = {}, state = {}, parentId = null, methods = [], metadata = {}, } = request.params;
+        this.logger.info(`Registering component: ${id} (${type})`);
+        // Check if component already exists
+        if (this.componentRegistry.has(id)) {
+            this.logger.warn(`Component ${id} already registered, updating instead`);
+            const updateRequest = new oRequest({
+                method: 'update_component',
+                params: { nodeId: id, props, state, metadata },
+                id: request.id,
+            });
+            await this._tool_update_component(updateRequest);
+            return {
+                success: true,
+                nodeId: id,
+                address: address,
+                message: 'Component already exists, updated instead',
+            };
+        }
+        const now = Date.now();
+        // Create component node
+        const componentNode = {
+            id,
+            type,
+            address: new oAddress(address),
+            props,
+            state,
+            parentId,
+            childIds: [],
+            methods,
+            registeredAt: now,
+            updatedAt: now,
+            metadata,
+        };
+        // Add to registry
+        this.componentRegistry.set(id, componentNode);
+        // If has parent, add as child to parent
+        if (parentId) {
+            const parent = this.componentRegistry.get(parentId);
+            if (parent) {
+                if (!parent.childIds.includes(id)) {
+                    parent.childIds.push(id);
+                    parent.updatedAt = now;
+                }
+            }
+            else {
+                this.logger.warn(`Parent ${parentId} not found for component ${id}, will register as orphan`);
+            }
+        }
+        this.logger.info(`Component ${id} registered successfully. Total components: ${this.componentRegistry.size}`);
+        return {
+            success: true,
+            nodeId: id,
+            address: componentNode.address.toString(),
+            message: 'Component registered successfully',
+        };
+    }
+    /**
+     * Unregister a UI component from the graph
+     */
+    async _tool_unregister_component(request) {
+        const { nodeId } = request.params;
+        this.logger.info(`Unregistering component: ${nodeId}`);
+        const component = this.componentRegistry.get(nodeId);
+        if (!component) {
+            this.logger.warn(`Component ${nodeId} not found`);
+            return {
+                success: false,
+                message: 'Component not found',
+            };
+        }
+        // Remove from parent's children
+        if (component.parentId) {
+            const parent = this.componentRegistry.get(component.parentId);
+            if (parent) {
+                parent.childIds = parent.childIds.filter((id) => id !== nodeId);
+                parent.updatedAt = Date.now();
+            }
+        }
+        // Recursively unregister all children
+        for (const childId of component.childIds) {
+            const childRequest = new oRequest({
+                method: 'unregister_component',
+                params: { nodeId: childId },
+                id: request.id,
+            });
+            await this._tool_unregister_component(childRequest);
+        }
+        // Remove method handlers
+        delete this.methodHandlers[nodeId];
+        // Remove from registry
+        this.componentRegistry.delete(nodeId);
+        this.logger.info(`Component ${nodeId} unregistered. Total components: ${this.componentRegistry.size}`);
+        return {
+            success: true,
+            message: 'Component unregistered successfully',
+        };
+    }
+    /**
+     * Update component props, state, or metadata
+     */
+    async _tool_update_component(request) {
+        const { nodeId, props, state, metadata } = request.params;
+        const component = this.componentRegistry.get(nodeId);
+        if (!component) {
+            this.logger.warn(`Component ${nodeId} not found for update`);
+            return {
+                success: false,
+                message: 'Component not found',
+            };
+        }
+        // Update props
+        if (props) {
+            component.props = { ...component.props, ...props };
+        }
+        // Update state
+        if (state) {
+            component.state = { ...component.state, ...state };
+        }
+        // Update metadata
+        if (metadata) {
+            component.metadata = { ...component.metadata, ...metadata };
+        }
+        component.updatedAt = Date.now();
+        this.logger.debug(`Component ${nodeId} updated`);
+        return {
+            success: true,
+            message: 'Component updated successfully',
+        };
+    }
+    /**
+     * Invoke a method on a component
+     */
+    async _tool_invoke_action(request) {
+        const { nodeId, method, params } = request.params;
+        this.logger.info(`Invoking ${method} on component ${nodeId}`);
+        const component = this.componentRegistry.get(nodeId);
+        if (!component) {
+            throw new Error(`Component ${nodeId} not found`);
+        }
+        if (!component.methods.includes(method)) {
+            throw new Error(`Method ${method} not available on component ${nodeId}`);
+        }
+        // Get method handler
+        const handler = this.methodHandlers[nodeId]?.[method];
+        if (!handler) {
+            throw new Error(`Method handler for ${method} not registered for component ${nodeId}`);
+        }
+        // Invoke handler
+        const result = await handler(params);
+        this.logger.debug(`Method ${method} invoked on ${nodeId}`);
+        return {
+            success: true,
+            result,
+        };
+    }
+    /**
+     * Query component hierarchy
+     */
+    async _tool_query_hierarchy(request) {
+        const { nodeId } = request.params;
+        const component = this.componentRegistry.get(nodeId);
+        if (!component) {
+            throw new Error(`Component ${nodeId} not found`);
+        }
+        // Get children
+        const children = component.childIds
+            .map((id) => this.componentRegistry.get(id))
+            .filter((c) => c !== undefined);
+        // Get parent
+        const parent = component.parentId
+            ? this.componentRegistry.get(component.parentId) || null
+            : null;
+        return {
+            node: component,
+            children,
+            parent,
+        };
+    }
+    /**
+     * Get all registered components (for debugging)
+     */
+    async _tool_list_components(request) {
+        const components = Array.from(this.componentRegistry.values());
+        return {
+            components,
+            count: components.length,
+        };
+    }
+    /**
+     * Get component tree structure
+     */
+    async _tool_get_tree(request) {
+        // Find root components (those without parents)
+        const roots = Array.from(this.componentRegistry.values()).filter((c) => !c.parentId);
+        const buildTree = (node) => {
+            const children = node.childIds
+                .map((id) => this.componentRegistry.get(id))
+                .filter((c) => c !== undefined)
+                .map((c) => buildTree(c));
+            return {
+                id: node.id,
+                type: node.type,
+                address: node.address.toString(),
+                props: node.props,
+                metadata: node.metadata,
+                children,
+            };
+        };
+        return {
+            roots: roots.map((r) => buildTree(r)),
+        };
+    }
+    /**
+     * Register a method handler for a component
+     * This is called from the client side to register callbacks
+     */
+    registerMethodHandler(nodeId, method, handler) {
+        if (!this.methodHandlers[nodeId]) {
+            this.methodHandlers[nodeId] = {};
+        }
+        this.methodHandlers[nodeId][method] = handler;
+        this.logger.debug(`Method handler ${method} registered for ${nodeId}`);
+    }
+    /**
+     * Unregister all method handlers for a component
+     */
+    unregisterMethodHandlers(nodeId) {
+        delete this.methodHandlers[nodeId];
+        this.logger.debug(`Method handlers unregistered for ${nodeId}`);
+    }
+    /**
+     * Get component by ID
+     */
+    getComponent(nodeId) {
+        return this.componentRegistry.get(nodeId);
+    }
+    /**
+     * Get all children of a component
+     */
+    getComponentChildren(nodeId) {
+        const component = this.componentRegistry.get(nodeId);
+        if (!component)
+            return [];
+        return component.childIds
+            .map((id) => this.componentRegistry.get(id))
+            .filter((c) => c !== undefined);
+    }
+    /**
+     * Get parent of a component
+     */
+    getParent(nodeId) {
+        const component = this.componentRegistry.get(nodeId);
+        if (!component || !component.parentId)
+            return null;
+        return this.componentRegistry.get(component.parentId) || null;
+    }
+}