@backbay/glia 0.2.0-alpha.1

package/dist/primitives/three/Graph3D/Graph3D.d.ts

@@ -0,0 +1,25 @@
+import { Graph3DHandle, GraphNodeId, GraphSnapshot, LayoutMode, LayoutOptions } from "./types";
+export interface Graph3DProps {
+    graph: GraphSnapshot;
+    selectedNodeId?: GraphNodeId | null;
+    focusedPath?: GraphNodeId[];
+    highlightedNodeIds?: GraphNodeId[];
+    dimUnhighlighted?: boolean;
+    layout?: LayoutMode;
+    layoutOptions?: LayoutOptions;
+    agentActivity?: {
+        mode: "idle" | "weaving" | "updating" | "explaining";
+        activeNodeIds?: GraphNodeId[];
+        activeEdgeIds?: string[];
+    };
+    onNodeClick?: (id: GraphNodeId) => void;
+    onNodeDoubleClick?: (id: GraphNodeId) => void;
+    onNodeHoverChange?: (id: GraphNodeId | null) => void;
+    onBackgroundClick?: () => void;
+    showGrid?: boolean;
+    enableInstancing?: boolean;
+    maxNodeCountForLabels?: number;
+    embedMode?: boolean;
+}
+export declare const Graph3D: import("react").ForwardRefExoticComponent<Graph3DProps & import("react").RefAttributes<Graph3DHandle>>;
+//# sourceMappingURL=Graph3D.d.ts.map

package/dist/primitives/three/Graph3D/Graph3D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Graph3D.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/Graph3D/Graph3D.tsx"],"names":[],"mappings":"AAQA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG/F,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,aAAa,CAAC;IAGrB,cAAc,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACpC,WAAW,CAAC,EAAE,WAAW,EAAE,CAAC;IAC5B,kBAAkB,CAAC,EAAE,WAAW,EAAE,CAAC;IACnC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,aAAa,CAAC,EAAE,aAAa,CAAC;IAG9B,aAAa,CAAC,EAAE;QACd,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,YAAY,CAAC;QACrD,aAAa,CAAC,EAAE,WAAW,EAAE,CAAC;QAC9B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;KAC1B,CAAC;IAGF,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,CAAC;IACxC,iBAAiB,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,CAAC;IAC9C,iBAAiB,CAAC,EAAE,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACrD,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;IAG/B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,eAAO,MAAM,OAAO,wGA0MnB,CAAC"}

package/dist/primitives/three/Graph3D/Graph3D.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { OrbitControls, Stars } from "@react-three/drei";
+import { useFrame, useThree } from "@react-three/fiber";
+import { AnimatePresence } from "framer-motion";
+import { forwardRef, useEffect, useImperativeHandle, useRef, useState } from "react";
+import * as THREE from "three";
+import { GraphEdge } from "./GraphEdge";
+import { GraphNode } from "./GraphNode";
+import { layoutCustom, layoutFibonacci, layoutForce, layoutRing } from "./utils";
+export const Graph3D = forwardRef(({ graph, selectedNodeId, focusedPath = [], highlightedNodeIds = [], dimUnhighlighted, layout = "fibonacci", layoutOptions = {}, agentActivity = { mode: "idle" }, onNodeClick, onNodeDoubleClick, onNodeHoverChange, onBackgroundClick, maxNodeCountForLabels = 20, embedMode = false, }, ref) => {
+    const { camera } = useThree();
+    const controlsRef = useRef(null);
+    const groupRef = useRef(null);
+    // State for positions map
+    const [positions, setPositions] = useState(new Map());
+    // State for current layout mode
+    const [currentLayout, setCurrentLayout] = useState(layout);
+    const [currentLayoutOptions, setCurrentLayoutOptions] = useState(layoutOptions);
+    // Calculate positions when graph or layout changes
+    useEffect(() => {
+        let newPositions;
+        switch (currentLayout) {
+            case "force":
+                newPositions = layoutForce(graph.nodes, graph.edges, currentLayoutOptions);
+                break;
+            case "ring":
+                newPositions = layoutRing(graph.nodes, currentLayoutOptions);
+                break;
+            case "custom":
+                newPositions = layoutCustom(graph.nodes);
+                break;
+            case "fibonacci":
+            default:
+                newPositions = layoutFibonacci(graph.nodes, currentLayoutOptions);
+                break;
+        }
+        setPositions(newPositions);
+    }, [graph, currentLayout, currentLayoutOptions]);
+    // Handle prop updates for layout
+    useEffect(() => {
+        setCurrentLayout(layout);
+        setCurrentLayoutOptions(layoutOptions);
+    }, [layout, layoutOptions]);
+    // Imperative API
+    useImperativeHandle(ref, () => ({
+        focusNode: (id, options) => {
+            const pos = positions.get(id);
+            if (pos && controlsRef.current) {
+                // Animate OrbitControls target
+                // Using a simple lerp logic or just setting it for now.
+                // Ideally we'd tween this, but direct assignment is okay for MVP interactivity.
+                // controlsRef.current.target.lerp(pos, 0.1);
+                // For immediate focus:
+                controlsRef.current.target.copy(pos);
+                if (options?.animateCamera) {
+                    // Move camera to a nice offset
+                    const offset = new THREE.Vector3(0, 2, 6);
+                    // We can't easily animate camera pos inside imperative handle without a loop or library
+                    // Just setting for now, assuming external animation or simple jump
+                    // Ideally: integration with GSAP or react-spring for camera
+                    camera.position.copy(pos).add(offset);
+                }
+            }
+        },
+        pulseNode: (_id, _options) => { },
+        highlightPath: (_ids, _options) => { },
+        showDiff: (_oldGraph, _newGraph, _options) => { },
+        setLayout: (mode, opts) => {
+            setCurrentLayout(mode);
+            if (opts)
+                setCurrentLayoutOptions(opts);
+        },
+        getNodePosition: (id) => {
+            return positions.get(id);
+        },
+    }));
+    // Slow rotation for "cinematic" feel (idle mode)
+    useFrame((_state, delta) => {
+        if (groupRef.current && agentActivity.mode === "idle" && !selectedNodeId) {
+            groupRef.current.rotation.y += delta * 0.02; // Slower rotation
+        }
+    });
+    // Determine visibility/dimming
+    const isNodeDimmed = (id) => {
+        if (!dimUnhighlighted)
+            return false;
+        if (selectedNodeId && id === selectedNodeId)
+            return false;
+        if (focusedPath.includes(id))
+            return false;
+        if (highlightedNodeIds.includes(id))
+            return false;
+        if (selectedNodeId || focusedPath.length > 0 || highlightedNodeIds.length > 0)
+            return true;
+        return false;
+    };
+    return (_jsxs(_Fragment, { children: [!embedMode && (_jsxs(_Fragment, { children: [_jsx("color", { attach: "background", args: ["#050812"] }), _jsx("fog", { attach: "fog", args: ["#050812", 8, 25] }), " ", _jsx(Stars, { radius: 90, depth: 40, count: 1800, factor: 3, saturation: 0, fade: true, speed: 0.3 }), _jsx("ambientLight", { intensity: 0.2 }), _jsx("pointLight", { position: [10, 10, 10], intensity: 0.5, color: "#4060ff" }), _jsx("pointLight", { position: [-10, -5, -10], intensity: 0.3, color: "#ff0080" }), _jsx("hemisphereLight", { args: ["#050812", "#000000", 0.5] })] })), _jsx(OrbitControls, { ref: controlsRef, makeDefault: true, enableDamping: true, dampingFactor: 0.05, rotateSpeed: 0.5, minDistance: 3, maxDistance: 16 }), _jsxs("mesh", { visible: false, scale: [100, 100, 100], onClick: () => onBackgroundClick?.(), children: [_jsx("sphereGeometry", { args: [1, 16, 16] }), _jsx("meshBasicMaterial", { side: THREE.BackSide })] }), _jsxs("group", { ref: groupRef, children: [graph.edges.map((edge) => {
+                        const start = positions.get(edge.source);
+                        const end = positions.get(edge.target);
+                        if (!start || !end)
+                            return null;
+                        const bothInPath = focusedPath.includes(edge.source) && focusedPath.includes(edge.target);
+                        const isDimmed = dimUnhighlighted && !bothInPath && (focusedPath.length > 0 || !!selectedNodeId);
+                        return (_jsx(GraphEdge, { edge: edge, start: start, end: end, isPathActive: bothInPath, isDimmed: isDimmed }, edge.id));
+                    }), _jsx(AnimatePresence, { children: graph.nodes.map((node) => {
+                            const pos = positions.get(node.id);
+                            if (!pos)
+                                return null;
+                            const isSelected = selectedNodeId === node.id;
+                            const isPathActive = focusedPath.includes(node.id);
+                            // Show label logic: hovered, selected, active path, or sparse graph
+                            // We pass `showLabel` as a base visibility, but hover handles itself
+                            const shouldShowLabel = isSelected ||
+                                isPathActive ||
+                                highlightedNodeIds.includes(node.id) ||
+                                graph.nodes.length < maxNodeCountForLabels;
+                            return (_jsx(GraphNode, { node: node, position: pos, isSelected: isSelected, isPathActive: isPathActive, isHovered: false, isDimmed: isNodeDimmed(node.id), showLabel: shouldShowLabel, onClick: onNodeClick, onDoubleClick: onNodeDoubleClick, onHover: onNodeHoverChange }, node.id));
+                        }) })] })] }));
+});
+Graph3D.displayName = "Graph3D";

package/dist/primitives/three/Graph3D/GraphEdge.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+import { GraphEdge as GraphEdgeData } from "./types";
+interface GraphEdgeProps {
+    edge: GraphEdgeData;
+    start: THREE.Vector3;
+    end: THREE.Vector3;
+    isPathActive?: boolean;
+    isDimmed?: boolean;
+}
+export declare const GraphEdge: ({ edge, start, end, isPathActive, isDimmed }: GraphEdgeProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=GraphEdge.d.ts.map

package/dist/primitives/three/Graph3D/GraphEdge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphEdge.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/Graph3D/GraphEdge.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,SAAS,CAAC;AAErD,UAAU,cAAc;IACtB,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC;IACrB,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,SAAS,GAAI,8CAA8C,cAAc,4CA+DrF,CAAC"}

package/dist/primitives/three/Graph3D/GraphEdge.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Line } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { useRef } from "react";
+export const GraphEdge = ({ edge, start, end, isPathActive, isDimmed }) => {
+    const lineRef = useRef(null);
+    // Determine style based on type and state
+    const isAgentPath = edge.type === "agentPath";
+    const isSuggested = edge.type === "suggested";
+    const isDistraction = edge.type === "distraction";
+    // Colors & Styles per spec
+    // Path: Cyan tint, thicker
+    // Suggested: Bright but transparent, dashed
+    // Distraction: Warm orange/red, dashed
+    // Default: Soft gray-blue
+    const color = isPathActive || isAgentPath
+        ? "#00f0ff" // Cyan
+        : isDistraction
+            ? "#ff6b4a" // Warm Orange/Red
+            : isSuggested
+                ? "#e0e7ff" // Cool white/blue
+                : "#a0b0d0"; // Soft gray-blue
+    const opacity = isDimmed
+        ? 0.03 // Faded out
+        : isPathActive || isAgentPath
+            ? 0.85 // High visibility
+            : isDistraction
+                ? 0.6 // Visible but ghost-like
+                : isSuggested
+                    ? 0.25 // Slightly reduced per feedback (was 0.35)
+                    : 0.08; // Subtle default
+    const width = isPathActive || isAgentPath ? 2.5 : isDistraction ? 1.5 : 1;
+    const dashed = isSuggested || isAgentPath || isPathActive || isDistraction;
+    useFrame((_state, delta) => {
+        // Animate flow for agent paths or active paths
+        if (lineRef.current && (isAgentPath || isPathActive || isSuggested || isDistraction)) {
+            if (lineRef.current.material) {
+                // Speed varies by type
+                const speed = isPathActive ? 1.5 : isAgentPath ? 1 : isDistraction ? 0.3 : 0.5;
+                lineRef.current.material.dashOffset -= delta * speed;
+            }
+        }
+    });
+    return (_jsx(Line, { ref: lineRef, points: [start, end], color: color, transparent: true, opacity: opacity, lineWidth: width, dashed: dashed, dashScale: isSuggested ? 2 : isDistraction ? 3 : 1.4, dashSize: isPathActive ? 0.22 : 0.16, gapSize: isPathActive ? 0.14 : 0.2, depthWrite: false, toneMapped: false }));
+};

package/dist/primitives/three/Graph3D/GraphNode.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from "three";
+import { GraphNode as GraphNodeData } from "./types";
+interface GraphNodeProps {
+    node: GraphNodeData;
+    position: THREE.Vector3;
+    isSelected?: boolean;
+    isHovered?: boolean;
+    isPathActive?: boolean;
+    isDimmed?: boolean;
+    showLabel?: boolean;
+    onClick?: (id: string) => void;
+    onDoubleClick?: (id: string) => void;
+    onHover?: (id: string | null) => void;
+}
+export declare const GraphNode: ({ node, position, isSelected, isHovered, isPathActive, isDimmed, showLabel, onClick, onDoubleClick, onHover, }: GraphNodeProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=GraphNode.d.ts.map

package/dist/primitives/three/Graph3D/GraphNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphNode.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/Graph3D/GraphNode.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,SAAS,CAAC;AAGrD,UAAU,cAAc;IACtB,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,aAAa,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACvC;AAED,eAAO,MAAM,SAAS,GAAI,gHAWvB,cAAc,4CA8MhB,CAAC"}

package/dist/primitives/three/Graph3D/GraphNode.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Html } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { motion } from "framer-motion";
+import { useMemo, useRef } from "react";
+import * as THREE from "three";
+import { getCategoryColor, getNodeSize } from "./utils";
+export const GraphNode = ({ node, position, isSelected, isHovered, isPathActive, isDimmed, showLabel, onClick, onDoubleClick, onHover, }) => {
+    // Calculate size based on spec
+    const baseSize = useMemo(() => getNodeSize(node.weight), [node.weight]);
+    const color = useMemo(() => getCategoryColor(node.category), [node.category]);
+    // Derived state flags
+    const isHighlighted = isSelected || isHovered || isPathActive;
+    const isActiveStatus = node.status === "active";
+    const isDeployingStatus = node.status === "candidate"; // candidate = deploying in our model
+    const isBlockedStatus = node.status === "blocked"; // blocked = error
+    // Emissive color logic: active path nodes shift slightly to cyan
+    const emissiveColor = useMemo(() => {
+        const baseColor = new THREE.Color(color);
+        if (isPathActive) {
+            return baseColor.lerp(new THREE.Color("#00f0ff"), 0.3);
+        }
+        if (isBlockedStatus) {
+            return baseColor.lerp(new THREE.Color("#ff4444"), 0.5);
+        }
+        return baseColor;
+    }, [color, isPathActive, isBlockedStatus]);
+    const groupRef = useRef(null);
+    const meshRef = useRef(null);
+    const didInitRef = useRef(false);
+    const targetScaleRef = useRef(new THREE.Vector3(1, 1, 1));
+    useFrame(({ clock }, delta) => {
+        const group = groupRef.current;
+        const mesh = meshRef.current;
+        if (!group || !mesh)
+            return;
+        const t = clock.elapsedTime;
+        const positionAlpha = 1 - Math.exp(-delta * 8);
+        const scaleAlpha = 1 - Math.exp(-delta * 12);
+        const getScaleScalar = () => {
+            if (isSelected)
+                return 1.2;
+            if (isHovered)
+                return 1.1;
+            if (isPathActive) {
+                return 1 + 0.05 * Math.sin((t * Math.PI * 2) / 2.5);
+            }
+            // Active nodes pulse more prominently
+            if (isActiveStatus) {
+                return 1 + 0.06 * Math.sin((t * Math.PI * 2) / 2);
+            }
+            // Deploying nodes pulse faster
+            if (isDeployingStatus) {
+                return 1 + 0.08 * Math.sin((t * Math.PI * 2) / 0.8);
+            }
+            // Blocked/error nodes have a rapid flicker
+            if (isBlockedStatus) {
+                return 1 + 0.04 * Math.sin((t * Math.PI * 2) / 0.5);
+            }
+            return 1 + 0.02 * Math.sin((t * Math.PI * 2) / 10);
+        };
+        if (!didInitRef.current) {
+            group.position.copy(position);
+            mesh.scale.setScalar(getScaleScalar());
+            didInitRef.current = true;
+            return;
+        }
+        group.position.lerp(position, positionAlpha);
+        targetScaleRef.current.setScalar(getScaleScalar());
+        mesh.scale.lerp(targetScaleRef.current, scaleAlpha);
+    });
+    return (_jsxs("group", { ref: groupRef, children: [_jsxs("mesh", { ref: meshRef, onClick: (e) => {
+                    e.stopPropagation();
+                    onClick?.(node.id);
+                }, onDoubleClick: (e) => {
+                    e.stopPropagation();
+                    onDoubleClick?.(node.id);
+                }, onPointerOver: (e) => {
+                    e.stopPropagation();
+                    onHover?.(node.id);
+                    document.body.style.cursor = "pointer";
+                }, onPointerOut: () => {
+                    onHover?.(null);
+                    document.body.style.cursor = "auto";
+                }, children: [_jsx("sphereGeometry", { args: [baseSize, 32, 32] }), _jsx("meshPhysicalMaterial", { color: color, emissive: emissiveColor, emissiveIntensity: isSelected ? 0.8 :
+                            isHovered ? 0.6 :
+                                isPathActive ? 0.5 :
+                                    isActiveStatus ? 0.45 :
+                                        isDeployingStatus ? 0.5 :
+                                            isBlockedStatus ? 0.6 :
+                                                0.2, roughness: 0.2, metalness: 0.6, transparent: true, opacity: isDimmed ? 0.15 : 0.9, transmission: 0.2, thickness: 0.5 })] }), (isHighlighted || isActiveStatus || isDeployingStatus) && (_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [baseSize * (isSelected ? 2 : isActiveStatus ? 1.8 : 1.6), 32, 32] }), _jsx("meshBasicMaterial", { color: isBlockedStatus ? "#ff4444" : emissiveColor, transparent: true, opacity: isSelected ? 0.15 : isActiveStatus ? 0.12 : isDeployingStatus ? 0.18 : 0.1, side: THREE.BackSide, blending: THREE.AdditiveBlending, depthWrite: false })] })), isActiveStatus && !isSelected && (_jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [_jsx("ringGeometry", { args: [baseSize * 1.5, baseSize * 1.55, 64] }), _jsx("meshBasicMaterial", { color: "#00ff88", side: THREE.DoubleSide, transparent: true, opacity: 0.4, blending: THREE.AdditiveBlending })] })), isSelected && (_jsxs("mesh", { rotation: [Math.PI / 2, 0, 0], children: [_jsx("ringGeometry", { args: [baseSize * 1.8, baseSize * 1.85, 64] }), _jsx("meshBasicMaterial", { color: color, side: THREE.DoubleSide, transparent: true, opacity: 0.6, blending: THREE.AdditiveBlending })] })), (showLabel || isHighlighted) && (_jsx(Html, { distanceFactor: 12, zIndexRange: [100, 0], style: { pointerEvents: "none" }, children: _jsxs(motion.div, { initial: { opacity: 0, y: 4 }, animate: { opacity: 1, y: -12 }, transition: { duration: 0.18 }, className: `
+              flex flex-col items-center
+              ${isHighlighted ? "scale-100" : "scale-95 opacity-40"}
+            `, children: [_jsx("div", { className: `
+                px-2 py-1 rounded-full border backdrop-blur-md transition-colors duration-300
+                ${isHighlighted
+                                ? "bg-black/80 border-white/25 shadow-[0_0_12px_rgba(0,0,0,0.5)]"
+                                : "bg-transparent border-transparent"}
+              `, children: _jsx("div", { className: `text-[9px] font-mono font-semibold whitespace-nowrap ${isHighlighted ? "text-white" : "text-white/55"}`, children: node.label }) }), isHighlighted && node.category && (_jsx("div", { className: "text-[7px] uppercase tracking-[0.18em] font-bold mt-1 px-1.5 py-px rounded border bg-black/40 backdrop-blur-sm", style: {
+                                color: color,
+                                borderColor: `${color}33`,
+                                boxShadow: `0 0 6px ${color}22`,
+                            }, children: node.category }))] }) }))] }));
+};

package/dist/primitives/three/Graph3D/types.d.ts

@@ -0,0 +1,62 @@
+import * as THREE from "three";
+export type GraphNodeId = string;
+export interface GraphNode {
+    id: GraphNodeId;
+    label: string;
+    category?: string;
+    weight?: number;
+    status?: "normal" | "active" | "candidate" | "completed" | "blocked";
+    pinned?: boolean;
+    positionHint?: [number, number, number];
+    meta?: Record<string, unknown>;
+    x?: number;
+    y?: number;
+    z?: number;
+    vx?: number;
+    vy?: number;
+    vz?: number;
+}
+export interface GraphEdge {
+    id: string;
+    source: GraphNodeId;
+    target: GraphNodeId;
+    type?: "default" | "requires" | "relates" | "suggested" | "agentPath" | "distraction";
+    weight?: number;
+    directed?: boolean;
+}
+export interface GraphSnapshot {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+export interface AgentActivity {
+    mode: "idle" | "weaving" | "updating" | "explaining";
+    activeNodeIds?: GraphNodeId[];
+    activeEdgeIds?: string[];
+}
+export type LayoutMode = "fibonacci" | "force" | "ring" | "custom";
+export interface LayoutOptions {
+    spacing?: number;
+    radius?: number;
+    repelStrength?: number;
+    linkStrength?: number;
+    gravity?: number;
+    animateLayout?: boolean;
+    iterations?: number;
+}
+export interface Graph3DHandle {
+    focusNode(id: GraphNodeId, options?: {
+        animateCamera?: boolean;
+    }): void;
+    pulseNode(id: GraphNodeId, options?: {
+        duration?: number;
+    }): void;
+    highlightPath(ids: GraphNodeId[], options?: {
+        animate?: boolean;
+    }): void;
+    showDiff(oldGraph: GraphSnapshot, newGraph: GraphSnapshot, options?: {
+        mode?: "fade" | "morph";
+    }): void;
+    setLayout(layout: LayoutMode, opts?: LayoutOptions): void;
+    getNodePosition(id: GraphNodeId): THREE.Vector3 | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/primitives/three/Graph3D/types.d.ts.map

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

package/dist/primitives/three/Graph3D/types.js

@@ -0,0 +1 @@
+export {};

package/dist/primitives/three/Graph3D/utils.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+import { GraphEdge, GraphNode, LayoutOptions } from "./types";
+export declare const CATEGORY_COLORS: Record<string, string>;
+export declare const getCategoryColor: (category?: string) => string;
+export declare const getNodeSize: (weight?: number) => number;
+export declare function layoutFibonacci(nodes: GraphNode[], options?: LayoutOptions): Map<string, THREE.Vector3>;
+export declare function layoutRing(nodes: GraphNode[], options?: LayoutOptions): Map<string, THREE.Vector3>;
+export declare function layoutCustom(nodes: GraphNode[]): Map<string, THREE.Vector3>;
+export declare function layoutForce(nodes: GraphNode[], edges: GraphEdge[], options?: LayoutOptions): Map<string, THREE.Vector3>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/primitives/three/Graph3D/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/Graph3D/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE9D,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAsBlD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,WAAW,MAAM,WAQjD,CAAC;AAGF,eAAO,MAAM,WAAW,GAAI,SAAQ,MAAY,WAI/C,CAAC;AAIF,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,GAAE,aAAkB,GAC1B,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAoB5B;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,GAAE,aAAkB,GAC1B,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CA0B5B;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAY3E;AAGD,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,EAAE,EAClB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,GAAE,aAAkB,GAC1B,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAkF5B"}

package/dist/primitives/three/Graph3D/utils.js

@@ -0,0 +1,145 @@
+import * as THREE from "three";
+export const CATEGORY_COLORS = {
+    ADHD: "#00d4e6", // Neon Cyan (slightly desaturated from #00f0ff)
+    AI: "#d000ff", // Magenta (slightly desaturated from #f000ff)
+    Infrastructure: "#cfd8ff", // Cool white/blue (softer than #e0e7ff)
+    Systems: "#00e08a", // Emerald (shifted from #00ff99)
+    Personal: "#f4c948", // Soft Gold (shifted from #ffd700)
+    // Mission Clusters
+    Mission: "#00d4e6", // Default Mission = Cyan
+    MissionA: "#00d4e6", // Cyan
+    MissionB: "#00e08a", // Emerald
+    MissionC: "#f4c948", // Gold
+    // Distraction
+    Distraction: "#ff4d4d", // Red/Warning
+    // Generic
+    Plan: "#00f0ff",
+    Step: "#a0b0d0",
+    Task: "#a0b0d0",
+    Rest: "#a0b0d0",
+    Admin: "#a0b0d0",
+};
+export const getCategoryColor = (category) => {
+    // Check direct match
+    if (CATEGORY_COLORS[category || ""])
+        return CATEGORY_COLORS[category || ""];
+    // Fallback or "Task" variants
+    if (category?.startsWith("Mission"))
+        return CATEGORY_COLORS["Mission"];
+    return "#888888";
+};
+// Helper to get node size based on weight
+export const getNodeSize = (weight = 0.5) => {
+    const baseRadius = 0.14; // slightly bigger base
+    const maxBump = 0.05; // but less spread between min/max
+    return baseRadius + weight * maxBump;
+};
+// Layout Algorithms
+export function layoutFibonacci(nodes, options = {}) {
+    const positions = new Map();
+    const radius = options.radius ?? 4; // Increased default radius for "Universe" feel
+    nodes.forEach((node, i) => {
+        // Fibonacci sphere distribution
+        const phi = Math.acos(-1 + (2 * i) / nodes.length);
+        const theta = Math.sqrt(nodes.length * Math.PI) * phi;
+        positions.set(node.id, new THREE.Vector3(radius * Math.cos(theta) * Math.sin(phi), radius * Math.sin(theta) * Math.sin(phi), radius * Math.cos(phi)));
+    });
+    return positions;
+}
+export function layoutRing(nodes, options = {}) {
+    const positions = new Map();
+    const radius = options.radius ?? 4;
+    // Arrange in a ring on the XZ plane
+    // "Top" of the circle (negative Z?) as start?
+    // Let's start at -Z (top in top-down view) and go clockwise.
+    // Standard math: 0 is +X. Clockwise means decreasing angle?
+    // Let's just do standard circle and rotate if needed.
+    // Start at -PI/2 (top) and go clockwise (+angle in 3D usually CCW around Y).
+    // Let's do: Top is -Z.
+    nodes.forEach((node, i) => {
+        const angle = (i / nodes.length) * Math.PI * 2;
+        // Offset by -PI/2 to start at "top" (negative Z) if we map to X/Z appropriately
+        // x = sin(angle), z = -cos(angle) starts at (0, -1) and goes clockwise?
+        // i=0 -> x=0, z=-1 (Top)
+        // i=small -> x>0, z~-1 (Top Right) -> Clockwise
+        positions.set(node.id, new THREE.Vector3(Math.sin(angle) * radius, 0, -Math.cos(angle) * radius));
+    });
+    return positions;
+}
+export function layoutCustom(nodes) {
+    const positions = new Map();
+    nodes.forEach((node) => {
+        if (node.positionHint) {
+            positions.set(node.id, new THREE.Vector3(...node.positionHint));
+        }
+        else {
+            positions.set(node.id, new THREE.Vector3(0, 0, 0));
+        }
+    });
+    return positions;
+}
+// Force-directed layout
+export function layoutForce(nodes, edges, options = {}) {
+    const positions = new Map();
+    const velocities = new Map();
+    // Initialize
+    nodes.forEach((node, i) => {
+        // Use fibonacci as seed if no prev positions, to avoid initial explosion
+        const phi = Math.acos(-1 + (2 * i) / nodes.length);
+        const theta = Math.sqrt(nodes.length * Math.PI) * phi;
+        const r = options.radius ?? 4;
+        positions.set(node.id, new THREE.Vector3(r * Math.cos(theta) * Math.sin(phi), r * Math.sin(theta) * Math.sin(phi), r * Math.cos(phi)));
+        velocities.set(node.id, new THREE.Vector3(0, 0, 0));
+    });
+    const iterations = options.iterations ?? 120; // Increased default iterations
+    const repelStrength = options.repelStrength ?? 8;
+    const linkStrength = options.linkStrength ?? 0.8;
+    const gravity = options.gravity ?? 0.05;
+    const damping = 0.8;
+    for (let i = 0; i < iterations; i++) {
+        // Repulsion
+        for (let j = 0; j < nodes.length; j++) {
+            for (let k = j + 1; k < nodes.length; k++) {
+                const nodeA = nodes[j];
+                const nodeB = nodes[k];
+                const posA = positions.get(nodeA.id);
+                const posB = positions.get(nodeB.id);
+                const delta = new THREE.Vector3().subVectors(posA, posB);
+                let dist = delta.length();
+                if (dist === 0) {
+                    dist = 0.01;
+                    delta.set(Math.random() - 0.5, Math.random() - 0.5, Math.random() - 0.5);
+                }
+                const force = delta.normalize().multiplyScalar(repelStrength / (dist * dist));
+                velocities.get(nodeA.id).add(force);
+                velocities.get(nodeB.id).sub(force);
+            }
+        }
+        // Attraction
+        edges.forEach((edge) => {
+            if (!positions.has(edge.source) || !positions.has(edge.target))
+                return;
+            const posA = positions.get(edge.source);
+            const posB = positions.get(edge.target);
+            const delta = new THREE.Vector3().subVectors(posB, posA);
+            const dist = delta.length();
+            const idealDist = options.spacing ?? 1.5;
+            const force = delta.normalize().multiplyScalar((dist - idealDist) * linkStrength);
+            velocities.get(edge.source).add(force);
+            velocities.get(edge.target).sub(force);
+        });
+        // Gravity
+        nodes.forEach((node) => {
+            const pos = positions.get(node.id);
+            const force = pos.clone().negate().multiplyScalar(gravity);
+            velocities.get(node.id).add(force);
+        });
+        // Apply
+        nodes.forEach((node) => {
+            const vel = velocities.get(node.id);
+            vel.multiplyScalar(damping);
+            positions.get(node.id).add(vel);
+        });
+    }
+    return positions;
+}

package/dist/primitives/three/IntelFeed/IntelFeed.d.ts

@@ -0,0 +1,3 @@
+import { type IntelFeedProps } from "./types";
+export declare function IntelFeed({ items, sources, maxItems, filterSeverity, filterSources, onItemClick, layout, autoScroll, bounds, position, rotation, }: IntelFeedProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=IntelFeed.d.ts.map

package/dist/primitives/three/IntelFeed/IntelFeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntelFeed.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/IntelFeed/IntelFeed.tsx"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,cAAc,EAEpB,MAAM,SAAS,CAAC;AAkJjB,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,OAAO,EACP,QAAa,EACb,cAAc,EACd,aAAa,EACb,WAAW,EACX,MAAoB,EACpB,UAAiB,EACjB,MAAM,EACN,QAAoB,EACpB,QAAoB,GACrB,EAAE,cAAc,2CAkHhB"}