@kiberon-labs/behave-graph-flow 1.0.0 → 3.0.0

package/tests/commandRegistry.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from 'vitest';
+import type { Node } from 'reactflow';
+import {
+  registerCoreProfile,
+  writeNodeSpecsToJSON
+} from '@kiberon-labs/behave-graph';
+import { System } from '../src/system/system.js';
+import {
+  commandStoreFactory,
+  type CommandContext
+} from '../src/store/commands.js';
+import {
+  contextMenuStoreFactory,
+  type ContextMenuItem
+} from '../src/store/contextMenu.js';
+
+const buildSystem = () => {
+  const reg = registerCoreProfile({
+    nodes: {},
+    values: {},
+    dependencies: {} as any
+  });
+  return new System({ values: reg.values, specs: writeNodeSpecsToJSON(reg) });
+};
+
+const node = (id: string): Node => ({
+  id,
+  type: 'behaveNode',
+  position: { x: 0, y: 0 },
+  data: { type: 'debug/log', configuration: {}, ports: {} } as any
+});
+
+// The command/context-menu registries are framework-free; a stub context is fine.
+const ctx = {} as CommandContext;
+
+describe('command registry', () => {
+  it('registers, runs, and unregisters by id', () => {
+    const store = commandStoreFactory().getState();
+    let ran = 0;
+    const off = store.register({ id: 'x.do', run: () => void ran++ });
+
+    expect(store.get('x.do')?.id).toBe('x.do');
+    store.run('x.do', ctx);
+    expect(ran).toBe(1);
+
+    off();
+    expect(store.get('x.do')).toBeUndefined();
+    store.run('x.do', ctx); // no-op, no throw
+    expect(ran).toBe(1);
+  });
+
+  it('register replaces an existing id (idempotent override)', () => {
+    const store = commandStoreFactory().getState();
+    store.register({ id: 'x', run: () => {} });
+    store.register({ id: 'x', title: 'Second', run: () => {} });
+    expect(store.list()).toHaveLength(1);
+    expect(store.get('x')?.title).toBe('Second');
+  });
+
+  it('skips a disabled command', () => {
+    const store = commandStoreFactory().getState();
+    let ran = false;
+    store.register({
+      id: 'x',
+      isEnabled: () => false,
+      run: () => {
+        ran = true;
+      }
+    });
+    store.run('x', ctx);
+    expect(ran).toBe(false);
+  });
+});
+
+describe('context-menu registry', () => {
+  const item = (over: Partial<ContextMenuItem>): ContextMenuItem => ({
+    id: 'i',
+    target: 'node',
+    label: 'L',
+    ...over
+  });
+
+  it('returns items for a target sorted by order', () => {
+    const store = contextMenuStoreFactory().getState();
+    store.register(item({ id: 'b', order: 20 }));
+    store.register(item({ id: 'a', order: 10 }));
+    store.register(item({ id: 'e', target: 'edge', order: 5 }));
+
+    const nodeIds = store.getItems('node').map((i) => i.id);
+    expect(nodeIds).toEqual(['a', 'b']); // edge item excluded, sorted
+  });
+
+  it('register replaces by id; unregister removes', () => {
+    const store = contextMenuStoreFactory().getState();
+    store.register(item({ id: 'a', label: 'One' }));
+    store.register(item({ id: 'a', label: 'Two' }));
+    expect(store.getItems('node')).toHaveLength(1);
+    expect(store.getItems('node')[0]!.label).toBe('Two');
+
+    store.unregister('a');
+    expect(store.getItems('node')).toHaveLength(0);
+  });
+});
+
+describe('System.runCommand (hotkeys/menubar dispatch path)', () => {
+  it('dispatches a default command against the focused session', () => {
+    const system = buildSystem();
+    const session = system.createSession('g'); // activates by default
+    session.nodeStore.getState().setNodes(() => [node('n1'), node('n2')]);
+
+    system.runCommand('selection.selectAll');
+
+    expect(session.nodeStore.getState().nodes.every((n) => n.selected)).toBe(
+      true
+    );
+  });
+
+  it('no-ops when there is no focused graph', () => {
+    const system = buildSystem();
+    expect(() => system.runCommand('selection.selectAll')).not.toThrow();
+  });
+
+  it('threads target context (e.g. nodeId) into the command', () => {
+    const system = buildSystem();
+    system.createSession('g');
+    let captured: string | undefined;
+    system.commandStore.getState().register({
+      id: 'probe',
+      run: (ctx) => {
+        captured = ctx.nodeId;
+      }
+    });
+
+    system.runCommand('probe', { nodeId: 'abc' });
+    expect(captured).toBe('abc');
+  });
+});

package/tests/components/edges/offsetBezier.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import { Position } from 'reactflow';
+import { getBetterBezierPath } from '@/components/edges/offsetBezier';
+
+describe('getBetterBezierPath', () => {
+  it('returns a bezier path string plus label/offset coordinates', () => {
+    const result = getBetterBezierPath({
+      sourceX: 0,
+      sourceY: 0,
+      targetX: 0,
+      targetY: 200
+    });
+
+    expect(result).toHaveLength(5);
+    const [path, labelX, labelY] = result;
+    expect(typeof path).toBe('string');
+    expect(path.startsWith('M0,0 C')).toBe(true);
+    expect(typeof labelX).toBe('number');
+    expect(typeof labelY).toBe('number');
+  });
+
+  it('offsets the control points vertically for bottom->top connections', () => {
+    const [path] = getBetterBezierPath({
+      sourceX: 0,
+      sourceY: 0,
+      sourcePosition: Position.Bottom,
+      targetX: 0,
+      targetY: 200,
+      targetPosition: Position.Top,
+      offset: 75
+    });
+
+    // source control = (0, 0 + 75), target control = (0, 200 - 75)
+    expect(path).toBe('M0,0 C0,75 0,125 0,200');
+  });
+
+  it('offsets the control points horizontally for left/right connections', () => {
+    const [path] = getBetterBezierPath({
+      sourceX: 0,
+      sourceY: 0,
+      sourcePosition: Position.Right,
+      targetX: 200,
+      targetY: 0,
+      targetPosition: Position.Left,
+      offset: 50
+    });
+
+    // source control = (0 + 50, 0), target control = (200 - 50, 0)
+    expect(path).toBe('M0,0 C50,0 150,0 200,0');
+  });
+});

package/tests/components/layoutController/utils.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import type { LayoutBase } from 'rc-dock';
+import {
+  findGraphPanel,
+  findTabInLayout,
+  removeTabFromLayout
+} from '@/components/layoutController/utils';
+
+const makeLayout = (): LayoutBase =>
+  ({
+    dockbox: {
+      id: 'root',
+      mode: 'horizontal',
+      children: [
+        {
+          id: 'graphs',
+          tabs: [{ id: 'tab-a' }, { id: 'tab-b' }]
+        },
+        {
+          id: 'sidebar',
+          tabs: [{ id: 'tab-c' }]
+        }
+      ]
+    }
+  }) as unknown as LayoutBase;
+
+describe('layoutController/utils', () => {
+  describe('findGraphPanel', () => {
+    it('locates the panel whose id is "graphs"', () => {
+      const panel = findGraphPanel(makeLayout());
+      expect(panel?.id).toBe('graphs');
+    });
+
+    it('returns null when no graph panel exists', () => {
+      const layout = {
+        dockbox: { id: 'root', children: [{ id: 'other', tabs: [] }] }
+      } as unknown as LayoutBase;
+      expect(findGraphPanel(layout)).toBeNull();
+    });
+  });
+
+  describe('findTabInLayout', () => {
+    it('finds the panel that owns a given tab', () => {
+      expect(findTabInLayout(makeLayout(), 'tab-b')?.id).toBe('graphs');
+      expect(findTabInLayout(makeLayout(), 'tab-c')?.id).toBe('sidebar');
+    });
+
+    it('returns null for an unknown tab', () => {
+      expect(findTabInLayout(makeLayout(), 'missing')).toBeNull();
+    });
+  });
+
+  describe('removeTabFromLayout', () => {
+    it('removes a tab while keeping the panel that still has tabs', () => {
+      const updated = removeTabFromLayout(makeLayout(), 'tab-a');
+      const graphsPanel = findTabInLayout(updated, 'tab-b');
+      expect(graphsPanel?.id).toBe('graphs');
+      expect(findTabInLayout(updated, 'tab-a')).toBeNull();
+    });
+
+    it('does not mutate the original layout', () => {
+      const layout = makeLayout();
+      removeTabFromLayout(layout, 'tab-a');
+      // original still has tab-a
+      expect(findTabInLayout(layout, 'tab-a')?.id).toBe('graphs');
+    });
+  });
+});

package/tests/components/panels/traces/utils.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import {
+  calculateTimeInterval,
+  clamp,
+  hashToHue
+} from '@/components/panels/traces/utils';
+
+describe('traces/utils', () => {
+  describe('hashToHue', () => {
+    it('is deterministic for the same input', () => {
+      expect(hashToHue('node-a')).toBe(hashToHue('node-a'));
+    });
+
+    it('always returns a hue in the [0, 360) range', () => {
+      for (const s of ['', 'a', 'flow/branch', 'a-very-long-identifier-123']) {
+        const hue = hashToHue(s);
+        expect(hue).toBeGreaterThanOrEqual(0);
+        expect(hue).toBeLessThan(360);
+        expect(Number.isInteger(hue)).toBe(true);
+      }
+    });
+
+    it('generally produces different hues for different inputs', () => {
+      expect(hashToHue('alpha')).not.toBe(hashToHue('beta'));
+    });
+  });
+
+  describe('clamp', () => {
+    it('returns the value when within range', () => {
+      expect(clamp(5, 0, 10)).toBe(5);
+    });
+    it('clamps below the minimum', () => {
+      expect(clamp(-3, 0, 10)).toBe(0);
+    });
+    it('clamps above the maximum', () => {
+      expect(clamp(42, 0, 10)).toBe(10);
+    });
+  });
+
+  describe('calculateTimeInterval', () => {
+    it('picks a "nice" interval roughly targeting 8 ticks', () => {
+      expect(calculateTimeInterval(8)).toBe(1);
+      expect(calculateTimeInterval(80)).toBe(10);
+      expect(calculateTimeInterval(800)).toBe(100);
+      expect(calculateTimeInterval(8000)).toBe(1000);
+    });
+
+    it('caps at the largest nice interval for very large ranges', () => {
+      expect(calculateTimeInterval(10_000_000)).toBe(10000);
+    });
+  });
+});

package/tests/contract.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import type { Node } from 'reactflow';
+import { deriveContract } from '../src/transformers/contract.js';
+
+const boundaryNode = (
+  id: string,
+  type: 'graph/input' | 'graph/output',
+  parameters: Array<{ name: string; valueTypeName: string; defaultValue?: any }>
+): Node => ({
+  id,
+  type: 'behaveNode',
+  position: { x: 0, y: 0 },
+  data: { type, configuration: { parameters }, ports: {} }
+});
+
+describe('graph contract derivation', () => {
+  it('derives graphInputs/graphOutputs from boundary nodes', () => {
+    const nodes: Node[] = [
+      boundaryNode('in', 'graph/input', [
+        { name: 'x', valueTypeName: 'float', defaultValue: 1 },
+        { name: 'label', valueTypeName: 'string' }
+      ]),
+      boundaryNode('out', 'graph/output', [
+        { name: 'y', valueTypeName: 'float' }
+      ]),
+      // a non-boundary node should be ignored
+      {
+        id: 'n',
+        type: 'behaveNode',
+        position: { x: 0, y: 0 },
+        data: { type: 'debug/log', configuration: {}, ports: {} }
+      }
+    ];
+
+    const { graphInputs, graphOutputs } = deriveContract(nodes);
+
+    expect(graphInputs).toEqual([
+      { key: 'x', valueType: 'float', defaultValue: 1, label: 'x' },
+      { key: 'label', valueType: 'string', label: 'label' }
+    ]);
+    expect(graphOutputs).toEqual([
+      { key: 'y', valueType: 'float', label: 'y' }
+    ]);
+  });
+
+  it('returns empty contract when there are no boundary nodes', () => {
+    const { graphInputs, graphOutputs } = deriveContract([]);
+    expect(graphInputs).toEqual([]);
+    expect(graphOutputs).toEqual([]);
+  });
+});

package/tests/contractSerialize.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import type { Node } from 'reactflow';
+import {
+  registerCoreProfile,
+  writeNodeSpecsToJSON
+} from '@kiberon-labs/behave-graph';
+import { System } from '../src/system/system.js';
+import { flowToBehave } from '../src/transformers/flowToBehave.js';
+
+const boundary = (
+  id: string,
+  type: 'graph/input' | 'graph/output',
+  params: Array<{ name: string; valueTypeName: string }>
+): Node => ({
+  id,
+  type: 'behaveNode',
+  position: { x: 0, y: 0 },
+  data: { type, configuration: { parameters: params }, ports: {} }
+});
+
+describe('contract serialization through flowToBehave', () => {
+  it('emits graphInputs/graphOutputs derived from boundary nodes', () => {
+    const coreRegistry = registerCoreProfile({
+      nodes: {},
+      values: {},
+      dependencies: {} as any
+    });
+    const specs = writeNodeSpecsToJSON(coreRegistry);
+    const system = new System({ values: coreRegistry.values, specs });
+    const session = system.createSession('graph');
+
+    const nodes: Node[] = [
+      boundary('in', 'graph/input', [{ name: 'x', valueTypeName: 'float' }]),
+      boundary('out', 'graph/output', [{ name: 'y', valueTypeName: 'float' }])
+    ];
+
+    const graph = flowToBehave(session, nodes, [], specs);
+
+    expect(graph.graphInputs).toEqual([
+      { key: 'x', valueType: 'float', label: 'x' }
+    ]);
+    expect(graph.graphOutputs).toEqual([
+      { key: 'y', valueType: 'float', label: 'y' }
+    ]);
+  });
+
+  it('omits the contract when there are no boundary nodes', () => {
+    const coreRegistry = registerCoreProfile({
+      nodes: {},
+      values: {},
+      dependencies: {} as any
+    });
+    const specs = writeNodeSpecsToJSON(coreRegistry);
+    const system = new System({ values: coreRegistry.values, specs });
+    const session = system.createSession('graph');
+
+    const graph = flowToBehave(session, [], [], specs);
+
+    expect(graph.graphInputs).toBeUndefined();
+    expect(graph.graphOutputs).toBeUndefined();
+  });
+});

package/tests/deriveSpans.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest';
+import type { SpanCollector, TraceSpan } from '../src/store/traces.js';
+import { computeDerivedSpans } from '../src/components/panels/traces/useDerivedSpans.js';
+import type { ViewState } from '../src/components/panels/traces/types.js';
+
+const FOLLOW: ViewState = { start: 0, range: 5000, follow: true };
+
+/** Minimal collector holding the given spans (lane defaults to 0). */
+const collectorOf = (spans: TraceSpan[]): SpanCollector => ({
+  capacity: 16,
+  spans,
+  writeIndex: spans.length,
+  size: spans.length,
+  nextId: spans.length + 1,
+  openByNodeId: new Map(),
+  laneOpen: []
+});
+
+const span = (over: Partial<TraceSpan>): TraceSpan => ({
+  id: 1,
+  nodeId: 'n',
+  name: 'n',
+  start: 0,
+  end: 0,
+  lane: 0,
+  ...over
+});
+
+describe('computeDerivedSpans , instant span visibility', () => {
+  it('renders an instant (start === end) span instead of collapsing to nothing', () => {
+    // A node that executes in 0ms: start === end. Previously maxEnd <= minStart
+    // made the derivation bail and render no lanes.
+    const derived = computeDerivedSpans(
+      collectorOf([span({ start: 0, end: 0 })]),
+      5000,
+      FOLLOW
+    );
+
+    expect(derived.size).toBe(1);
+    expect(derived.laneData).toHaveLength(1);
+    const visuals = derived.laneData[0]!.visualSpans;
+    expect(visuals).toHaveLength(1);
+    // It has real, clickable width…
+    expect(visuals[0]!.widthPct).toBeGreaterThan(0);
+    // …but its reported duration is still the true 0ms.
+    expect(visuals[0]!.durationMs).toBe(0);
+  });
+
+  it('reports the true duration for a normal span and keeps it visible', () => {
+    const derived = computeDerivedSpans(
+      collectorOf([span({ start: 2, end: 7 })]),
+      5000,
+      FOLLOW
+    );
+    const v = derived.laneData[0]!.visualSpans[0]!;
+    expect(v.durationMs).toBe(5);
+    expect(v.widthPct).toBeGreaterThan(0);
+  });
+
+  it('labels ticks relative to the first span, not the raw clock', () => {
+    // Start at a large absolute time (as performance.now() produces); the first
+    // tick label should be relative (~0), not the absolute value.
+    const derived = computeDerivedSpans(
+      collectorOf([span({ start: 1_000_000, end: 1_000_010 })]),
+      0, // window 0 ⇒ fit all
+      FOLLOW
+    );
+    expect(derived.ticks.length).toBeGreaterThan(0);
+    expect(derived.ticks[0]!.time).toBeLessThan(1000);
+  });
+});

package/tests/flowToBehave.test.ts

@@ -8,18 +8,41 @@ import rawFlowGraph from '../../../graphs/react-flow/graph.json';
 import { behaveToFlow } from '../src/transformers/behaveToFlow.js';
 import { flowToBehave } from '../src/transformers/flowToBehave.js';
 import { it, expect } from 'vitest';
+import { System } from '@/system/system';
 
 const flowGraph = rawFlowGraph as GraphJSON;
 
 const [nodes, edges] = behaveToFlow(flowGraph);
 
 it('transforms from flow to behave', () => {
-  const registry = registerCoreProfile({
+  const coreRegistry = registerCoreProfile({
     nodes: {},
     values: {},
     dependencies: {}
   });
-  const specJSON = writeNodeSpecsToJSON(registry);
-  const output = flowToBehave(nodes, edges, specJSON);
-  expect(output).toEqual(flowGraph);
+  const specJSON = writeNodeSpecsToJSON(coreRegistry);
+  const registry = {
+    values: coreRegistry.values,
+    specs: specJSON
+  };
+  const system = new System(registry);
+  const session = system.createSession('graph');
+  const output = flowToBehave(session, nodes, edges, specJSON);
+
+  // Remove position metadata from expected graph since we no longer include it
+  const expectedGraph = {
+    ...flowGraph,
+    nodes: flowGraph.nodes.map((node) => {
+      const { metadata, ...rest } = node as any;
+      if (metadata) {
+        const { positionX, positionY, ...remainingMetadata } = metadata;
+        return Object.keys(remainingMetadata).length > 0
+          ? { ...rest, metadata: remainingMetadata }
+          : rest;
+      }
+      return node;
+    })
+  };
+
+  expect(output).toEqual(expectedGraph);
 });

package/tests/hotkeys.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import {
+  registerCoreProfile,
+  writeNodeSpecsToJSON
+} from '@kiberon-labs/behave-graph';
+import { System } from '../src/system/system.js';
+import { formatTrigger } from '../src/store/hotKeys.js';
+
+const buildSystem = () => {
+  const reg = registerCoreProfile({
+    nodes: {},
+    values: {},
+    dependencies: {} as any
+  });
+  return new System({ values: reg.values, specs: writeNodeSpecsToJSON(reg) });
+};
+
+describe('formatTrigger', () => {
+  it('capitalizes modifiers and single keys', () => {
+    expect(formatTrigger('ctrl+s')).toBe('Ctrl+S');
+    expect(formatTrigger('shift+alt+f')).toBe('Shift+Alt+F');
+  });
+
+  it('maps arrow keys to glyphs', () => {
+    expect(formatTrigger('ctrl+shift+left')).toBe('Ctrl+Shift+←');
+    expect(formatTrigger('ctrl+shift+right')).toBe('Ctrl+Shift+→');
+  });
+
+  it('prefers the ctrl variant when several triggers are bound', () => {
+    expect(formatTrigger(['command+c', 'ctrl+c'])).toBe('Ctrl+C');
+  });
+
+  it('returns undefined for empty/unset triggers', () => {
+    expect(formatTrigger(undefined)).toBeUndefined();
+    expect(formatTrigger('')).toBeUndefined();
+    expect(formatTrigger([])).toBeUndefined();
+  });
+});
+
+describe('getCommandKeybinding', () => {
+  it('auto-detects the shortcut for a command-backed binding', () => {
+    const sys = buildSystem();
+    const store = sys.hotKeyStore.getState();
+    expect(store.getCommandKeybinding('selection.copy')).toBe('Ctrl+C');
+    expect(store.getCommandKeybinding('editor.save')).toBe('Ctrl+S');
+  });
+
+  it('resolves handler-only bindings via hintCommand', () => {
+    const sys = buildSystem();
+    const store = sys.hotKeyStore.getState();
+    expect(store.getCommandKeybinding('node.traceUpstream')).toBe(
+      'Ctrl+Shift+←'
+    );
+  });
+
+  it('returns undefined for a command with no bound key', () => {
+    const sys = buildSystem();
+    const store = sys.hotKeyStore.getState();
+    expect(store.getCommandKeybinding('node.focus')).toBeUndefined();
+    expect(store.getCommandKeybinding('does.not.exist')).toBeUndefined();
+  });
+
+  it('reflects a rebind live, and picks up runtime-registered commands', () => {
+    const sys = buildSystem();
+    const store = sys.hotKeyStore.getState();
+
+    // Rebinding the action updates the derived hint.
+    store.register({ action: 'SAVE', trigger: 'ctrl+k' });
+    expect(sys.hotKeyStore.getState().getCommandKeybinding('editor.save')).toBe(
+      'Ctrl+K'
+    );
+
+    // A runtime binding that names its command becomes resolvable.
+    store.register({ action: 'RUN', trigger: 'p', command: 'graph.run' });
+    expect(sys.hotKeyStore.getState().getCommandKeybinding('graph.run')).toBe(
+      'P'
+    );
+  });
+});