@lov3kaizen/agentsea-debugger 0.5.1

package/dist/visualization/index.d.ts

@@ -0,0 +1,123 @@
+import { m as Recording, e as Decision, S as StepType } from '../recording.types-Ck7pbikw.js';
+import { a as DecisionTree, D as DecisionTreeNode, f as FlowGraph, F as FlowGraphNode, d as FlowGraphEdge } from '../visualization.types-dWjGE037.js';
+
+interface NodeOptions {
+    label: string;
+    type: 'decision' | 'outcome' | 'action' | 'branch';
+    decision?: Decision;
+    stepIndex?: number;
+    parentId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface TreeBuildOptions {
+    includeToolCalls?: boolean;
+    allSteps?: boolean;
+    maxDepth?: number;
+    collapseSimilar?: boolean;
+}
+interface LayoutOptions {
+    direction?: 'horizontal' | 'vertical';
+    nodeSpacing?: number;
+    levelSpacing?: number;
+    nodeWidth?: number;
+    nodeHeight?: number;
+}
+declare class DecisionTreeBuilder {
+    private nodes;
+    private rootId?;
+    private buildOptions;
+    private layoutOptions;
+    constructor(buildOptions?: TreeBuildOptions, layoutOptions?: LayoutOptions);
+    build(recording: Recording): DecisionTree;
+    private processStep;
+    private addDecisionNode;
+    private getStepLabel;
+    addNode(options: NodeOptions): DecisionTreeNode;
+    getNode(id: string): DecisionTreeNode | undefined;
+    getRoot(): DecisionTreeNode | undefined;
+    getNodes(): DecisionTreeNode[];
+    getNodesAtDepth(depth: number): DecisionTreeNode[];
+    getDepth(): number;
+    findPath(nodeId: string): DecisionTreeNode[];
+    findByStepIndex(stepIndex: number): DecisionTreeNode[];
+    findDecisionNodes(): DecisionTreeNode[];
+    clear(): void;
+    export(): DecisionTree;
+    toMermaid(): string;
+    private getMermaidShape;
+    calculateLayout(): Map<string, {
+        x: number;
+        y: number;
+    }>;
+}
+declare function createDecisionTreeBuilder(buildOptions?: TreeBuildOptions, layoutOptions?: LayoutOptions): DecisionTreeBuilder;
+
+interface NodeStyle {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    shape?: 'rectangle' | 'ellipse' | 'diamond' | 'hexagon';
+    fontSize?: number;
+    textColor?: string;
+}
+interface EdgeStyle {
+    stroke?: string;
+    strokeWidth?: number;
+    lineType?: 'solid' | 'dashed' | 'dotted';
+    arrowType?: 'arrow' | 'none' | 'diamond';
+    curveType?: 'straight' | 'bezier' | 'step';
+}
+interface GraphBuildOptions {
+    groupSimilar?: boolean;
+    includeDurations?: boolean;
+    includeToolDetails?: boolean;
+    maxNodes?: number;
+    nodeStyles?: Partial<Record<StepType, NodeStyle>>;
+}
+declare class FlowGraphBuilder {
+    private nodes;
+    private edges;
+    private options;
+    private nodeStyles;
+    constructor(options?: GraphBuildOptions);
+    build(recording: Recording): FlowGraph;
+    private createNodeFromStep;
+    private getStepLabel;
+    private getStepMetadata;
+    private updateNodeForGroup;
+    addNode(options: {
+        label: string;
+        type: StepType;
+        stepIndex?: number;
+        style?: NodeStyle;
+        metadata?: Record<string, unknown>;
+    }): FlowGraphNode;
+    addEdge(sourceId: string, targetId: string, options?: {
+        label?: string;
+        style?: EdgeStyle;
+        durationMs?: number;
+    }): FlowGraphEdge;
+    getNode(id: string): FlowGraphNode | undefined;
+    getNodes(): FlowGraphNode[];
+    getNodesByType(type: StepType): FlowGraphNode[];
+    getEdge(id: string): FlowGraphEdge | undefined;
+    getEdges(): FlowGraphEdge[];
+    getEdgesFrom(nodeId: string): FlowGraphEdge[];
+    getEdgesTo(nodeId: string): FlowGraphEdge[];
+    findPath(startId: string, endId: string): FlowGraphNode[] | null;
+    getStats(): {
+        nodeCount: number;
+        edgeCount: number;
+        nodesByType: Record<string, number>;
+        avgDuration: number;
+    };
+    clear(): void;
+    export(): FlowGraph;
+    toMermaid(): string;
+    private getMermaidShape;
+    toDOT(): string;
+    private getDOTShape;
+}
+declare function createFlowGraphBuilder(options?: GraphBuildOptions): FlowGraphBuilder;
+
+export { DecisionTreeBuilder, type EdgeStyle, FlowGraphBuilder, type GraphBuildOptions, type LayoutOptions, type NodeOptions, type NodeStyle, type TreeBuildOptions, createDecisionTreeBuilder, createFlowGraphBuilder };