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

package/tests/callSubgraphSync.test.ts

@@ -0,0 +1,148 @@
+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 { setupCallSubgraphSync } from '../src/generators/callSubgraphSync.js';
+
+const buildSystem = () => {
+  const registry = registerCoreProfile({
+    nodes: {},
+    values: {},
+    dependencies: {} as any
+  });
+  const specs = writeNodeSpecsToJSON(registry);
+  return new System({ values: registry.values, specs });
+};
+
+const outputBoundary = (
+  id: string,
+  params: Array<{ id?: string; name: string; valueTypeName: string }>
+): Node => ({
+  id,
+  type: 'behaveNode',
+  position: { x: 0, y: 0 },
+  data: {
+    type: 'graph/output',
+    configuration: { parameters: params },
+    ports: {}
+  }
+});
+
+const callNode = (id: string, subgraphId: string): Node => ({
+  id,
+  type: 'behaveNode',
+  position: { x: 0, y: 0 },
+  data: { type: 'flow/callSubgraph', configuration: { subgraphId }, ports: {} }
+});
+
+const getNode = (session: { nodeStore: any }, id: string): Node =>
+  session.nodeStore.getState().nodes.find((n: Node) => n.id === id);
+
+describe('call subgraph contract sync', () => {
+  it('updates a call node when the referenced subgraph contract changes after creation', () => {
+    const system = buildSystem();
+    const caller = system.createSession('caller');
+    const dispose = setupCallSubgraphSync(system);
+
+    // `sub` is created AFTER the sync is registered , exercises the session
+    // extension applying to future graphs, not just existing ones.
+    const sub = system.createSession('sub');
+
+    // A call node referencing `sub`, created while `sub` has no outputs yet.
+    caller.nodeStore.getState().setNodes(() => [callNode('call1', sub.id)]);
+    expect(getNode(caller, 'call1').data.configuration.outputs ?? []).toEqual(
+      []
+    );
+
+    // Now author the subgraph's output contract.
+    sub.nodeStore
+      .getState()
+      .setNodes(() => [
+        outputBoundary('out', [
+          { id: 'o1', name: 'result', valueTypeName: 'float' }
+        ])
+      ]);
+
+    // The call node should have picked up the new contract reactively , no
+    // re-selection required.
+    const synced = getNode(caller, 'call1');
+    expect(synced.data.configuration.outputs).toEqual([
+      { id: 'o1', name: 'result', valueTypeName: 'float' }
+    ]);
+    expect(synced.data.dynamicPorts.outputs).toEqual([
+      { name: 'o1', key: 'o1', label: 'result', valueType: 'float' }
+    ]);
+
+    // Rename the param: the call node tracks the change (stable id, new label).
+    sub.nodeStore
+      .getState()
+      .setNodes(() => [
+        outputBoundary('out', [
+          { id: 'o1', name: 'renamed', valueTypeName: 'float' }
+        ])
+      ]);
+    expect(getNode(caller, 'call1').data.configuration.outputs).toEqual([
+      { id: 'o1', name: 'renamed', valueTypeName: 'float' }
+    ]);
+
+    dispose();
+  });
+
+  it('does not rewrite call nodes on non-contract edits (e.g. dragging)', () => {
+    const system = buildSystem();
+    const caller = system.createSession('caller');
+    const sub = system.createSession('sub');
+    const dispose = setupCallSubgraphSync(system);
+
+    sub.nodeStore
+      .getState()
+      .setNodes(() => [
+        outputBoundary('out', [
+          { id: 'o1', name: 'result', valueTypeName: 'float' }
+        ])
+      ]);
+    caller.nodeStore.getState().setNodes(() => [callNode('call1', sub.id)]);
+
+    const before = getNode(caller, 'call1');
+    // A position-only change to the subgraph must not churn the call node.
+    sub.nodeStore
+      .getState()
+      .setNodes((prev: Node[]) =>
+        prev.map((n) =>
+          n.id === 'out' ? { ...n, position: { x: 50, y: 50 } } : n
+        )
+      );
+    const after = getNode(caller, 'call1');
+
+    // Same object identity ⇒ the call node was not rewritten.
+    expect(after).toBe(before);
+
+    dispose();
+  });
+
+  it('stops syncing after dispose', () => {
+    const system = buildSystem();
+    const caller = system.createSession('caller');
+    const sub = system.createSession('sub');
+    const dispose = setupCallSubgraphSync(system);
+
+    caller.nodeStore.getState().setNodes(() => [callNode('call1', sub.id)]);
+    dispose();
+
+    sub.nodeStore
+      .getState()
+      .setNodes(() => [
+        outputBoundary('out', [
+          { id: 'o1', name: 'result', valueTypeName: 'float' }
+        ])
+      ]);
+
+    // No sync after dispose ⇒ contract not propagated.
+    expect(getNode(caller, 'call1').data.configuration.outputs ?? []).toEqual(
+      []
+    );
+  });
+});

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/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

@@ -26,7 +26,8 @@ it('transforms from flow to behave', () => {
     specs: specJSON
   };
   const system = new System(registry);
-  const output = flowToBehave(system, nodes, edges, specJSON);
+  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 = {

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'
+    );
+  });
+});