@plures/runebook 0.4.0

package/src/lib/stores/canvas-praxis.ts

@@ -0,0 +1,268 @@
+// Praxis-based canvas state management for RuneBook
+// Uses Praxis reactive engine for type-safe, testable state management
+
+import { createPraxisEngine, defineEvent, defineRule, PraxisRegistry } from '@plures/praxis';
+import { createPraxisStore } from '@plures/praxis/svelte';
+import type { PraxisState, PraxisEvent } from '@plures/praxis';
+import type { Canvas, CanvasNode, Connection } from '../types/canvas';
+
+// Define the canvas context type
+export interface CanvasContext {
+  canvas: Canvas;
+  nodeData: Record<string, any>; // Node output data: `${nodeId}:${portId}` -> data
+}
+
+// Define events for canvas operations
+export const AddNodeEvent = defineEvent<'ADD_NODE', { node: CanvasNode }>('ADD_NODE');
+export const RemoveNodeEvent = defineEvent<'REMOVE_NODE', { nodeId: string }>('REMOVE_NODE');
+export const UpdateNodeEvent = defineEvent<'UPDATE_NODE', { nodeId: string; updates: Partial<CanvasNode> }>('UPDATE_NODE');
+export const UpdateNodePositionEvent = defineEvent<'UPDATE_NODE_POSITION', { nodeId: string; x: number; y: number }>('UPDATE_NODE_POSITION');
+export const AddConnectionEvent = defineEvent<'ADD_CONNECTION', { connection: Connection }>('ADD_CONNECTION');
+export const RemoveConnectionEvent = defineEvent<'REMOVE_CONNECTION', { from: string; to: string; fromPort: string; toPort: string }>('REMOVE_CONNECTION');
+export const LoadCanvasEvent = defineEvent<'LOAD_CANVAS', { canvas: Canvas }>('LOAD_CANVAS');
+export const ClearCanvasEvent = defineEvent<'CLEAR_CANVAS', {}>('CLEAR_CANVAS');
+export const UpdateNodeDataEvent = defineEvent<'UPDATE_NODE_DATA', { nodeId: string; portId: string; data: any }>('UPDATE_NODE_DATA');
+
+// Define rules for canvas operations
+const addNodeRule = defineRule<CanvasContext>({
+  id: 'canvas.addNode',
+  description: 'Add a new node to the canvas',
+  impl: (state, events) => {
+    const evt = events.find(AddNodeEvent.is);
+    if (!evt) return [];
+    
+    state.context.canvas.nodes = [...state.context.canvas.nodes, evt.payload.node];
+    return [];
+  },
+});
+
+const removeNodeRule = defineRule<CanvasContext>({
+  id: 'canvas.removeNode',
+  description: 'Remove a node from the canvas',
+  impl: (state, events) => {
+    const evt = events.find(RemoveNodeEvent.is);
+    if (!evt) return [];
+    
+    const { nodeId } = evt.payload;
+    state.context.canvas.nodes = state.context.canvas.nodes.filter(n => n.id !== nodeId);
+    state.context.canvas.connections = state.context.canvas.connections.filter(
+      c => c.from !== nodeId && c.to !== nodeId
+    );
+    
+    // Remove node data
+    const prefix = `${nodeId}:`;
+    state.context.nodeData = Object.fromEntries(
+      Object.entries(state.context.nodeData).filter(([key]) => !key.startsWith(prefix))
+    );
+    
+    return [];
+  },
+});
+
+const updateNodeRule = defineRule<CanvasContext>({
+  id: 'canvas.updateNode',
+  description: 'Update a node\'s properties',
+  impl: (state, events) => {
+    const evt = events.find(UpdateNodeEvent.is);
+    if (!evt) return [];
+    
+    const { nodeId, updates } = evt.payload;
+    const nodeIndex = state.context.canvas.nodes.findIndex(n => n.id === nodeId);
+    if (nodeIndex !== -1) {
+      state.context.canvas.nodes[nodeIndex] = {
+        ...state.context.canvas.nodes[nodeIndex],
+        ...updates
+      } as CanvasNode;
+    }
+    
+    return [];
+  },
+});
+
+const updateNodePositionRule = defineRule<CanvasContext>({
+  id: 'canvas.updateNodePosition',
+  description: 'Update a node\'s position',
+  impl: (state, events) => {
+    const evt = events.find(UpdateNodePositionEvent.is);
+    if (!evt) return [];
+    
+    const { nodeId, x, y } = evt.payload;
+    const nodeIndex = state.context.canvas.nodes.findIndex(n => n.id === nodeId);
+    if (nodeIndex !== -1) {
+      state.context.canvas.nodes[nodeIndex].position = { x, y };
+    }
+    
+    return [];
+  },
+});
+
+const addConnectionRule = defineRule<CanvasContext>({
+  id: 'canvas.addConnection',
+  description: 'Add a connection between nodes',
+  impl: (state, events) => {
+    const evt = events.find(AddConnectionEvent.is);
+    if (!evt) return [];
+    
+    state.context.canvas.connections = [...state.context.canvas.connections, evt.payload.connection];
+    return [];
+  },
+});
+
+const removeConnectionRule = defineRule<CanvasContext>({
+  id: 'canvas.removeConnection',
+  description: 'Remove a connection',
+  impl: (state, events) => {
+    const evt = events.find(RemoveConnectionEvent.is);
+    if (!evt) return [];
+    
+    const { from, to, fromPort, toPort } = evt.payload;
+    state.context.canvas.connections = state.context.canvas.connections.filter(
+      c => !(c.from === from && c.to === to && c.fromPort === fromPort && c.toPort === toPort)
+    );
+    
+    return [];
+  },
+});
+
+const loadCanvasRule = defineRule<CanvasContext>({
+  id: 'canvas.loadCanvas',
+  description: 'Load a canvas from data',
+  impl: (state, events) => {
+    const evt = events.find(LoadCanvasEvent.is);
+    if (!evt) return [];
+    
+    state.context.canvas = evt.payload.canvas;
+    return [];
+  },
+});
+
+const clearCanvasRule = defineRule<CanvasContext>({
+  id: 'canvas.clearCanvas',
+  description: 'Clear the canvas',
+  impl: (state, events) => {
+    const evt = events.find(ClearCanvasEvent.is);
+    if (!evt) return [];
+    
+    state.context.canvas = {
+      id: 'default',
+      name: 'Untitled Canvas',
+      description: '',
+      nodes: [],
+      connections: [],
+      version: '1.0.0'
+    };
+    state.context.nodeData = {};
+    
+    return [];
+  },
+});
+
+const updateNodeDataRule = defineRule<CanvasContext>({
+  id: 'canvas.updateNodeData',
+  description: 'Update node output data',
+  impl: (state, events) => {
+    const evt = events.find(UpdateNodeDataEvent.is);
+    if (!evt) return [];
+    
+    const { nodeId, portId, data } = evt.payload;
+    state.context.nodeData[`${nodeId}:${portId}`] = data;
+    
+    return [];
+  },
+});
+
+// Create the registry and register all rules
+const registry = new PraxisRegistry<CanvasContext>();
+registry.registerRule(addNodeRule);
+registry.registerRule(removeNodeRule);
+registry.registerRule(updateNodeRule);
+registry.registerRule(updateNodePositionRule);
+registry.registerRule(addConnectionRule);
+registry.registerRule(removeConnectionRule);
+registry.registerRule(loadCanvasRule);
+registry.registerRule(clearCanvasRule);
+registry.registerRule(updateNodeDataRule);
+
+// Create the reactive engine with initial state
+export const canvasEngine = createPraxisEngine<CanvasContext>({
+  initialContext: {
+    canvas: {
+      id: 'default',
+      name: 'Untitled Canvas',
+      description: '',
+      nodes: [],
+      connections: [],
+      version: '1.0.0'
+    },
+    nodeData: {}
+  },
+  registry
+});
+
+// Create the Praxis store that properly notifies subscribers
+export const canvasPraxisStoreInstance = createPraxisStore<CanvasContext>(canvasEngine);
+
+// Export a convenience API that matches the old store interface
+export const canvasPraxisStore = {
+  // The reactive context - use in Svelte components with $derived
+  get context() {
+    return canvasEngine.getContext();
+  },
+  
+  get canvas() {
+    return canvasEngine.getContext().canvas;
+  },
+  
+  get nodeData() {
+    return canvasEngine.getContext().nodeData;
+  },
+  
+  // Actions
+  addNode: (node: CanvasNode) => {
+    canvasPraxisStoreInstance.dispatch([AddNodeEvent.create({ node })]);
+  },
+  
+  removeNode: (nodeId: string) => {
+    canvasPraxisStoreInstance.dispatch([RemoveNodeEvent.create({ nodeId })]);
+  },
+  
+  updateNode: (nodeId: string, updates: Partial<CanvasNode>) => {
+    canvasPraxisStoreInstance.dispatch([UpdateNodeEvent.create({ nodeId, updates })]);
+  },
+  
+  updateNodePosition: (nodeId: string, x: number, y: number) => {
+    canvasPraxisStoreInstance.dispatch([UpdateNodePositionEvent.create({ nodeId, x, y })]);
+  },
+  
+  addConnection: (connection: Connection) => {
+    canvasPraxisStoreInstance.dispatch([AddConnectionEvent.create({ connection })]);
+  },
+  
+  removeConnection: (from: string, to: string, fromPort: string, toPort: string) => {
+    canvasPraxisStoreInstance.dispatch([RemoveConnectionEvent.create({ from, to, fromPort, toPort })]);
+  },
+  
+  loadCanvas: (canvas: Canvas) => {
+    canvasPraxisStoreInstance.dispatch([LoadCanvasEvent.create({ canvas })]);
+  },
+  
+  clear: () => {
+    canvasPraxisStoreInstance.dispatch([ClearCanvasEvent.create({})]);
+  },
+  
+  updateNodeData: (nodeId: string, portId: string, data: any) => {
+    canvasPraxisStoreInstance.dispatch([UpdateNodeDataEvent.create({ nodeId, portId, data })]);
+  },
+  
+  // Helper to get node input data from connections
+  getNodeInputData: (nodeId: string, portId: string) => {
+    const context = canvasEngine.getContext();
+    const connections = context.canvas.connections;
+    const nodeData = context.nodeData;
+    const connection = connections.find(c => c.to === nodeId && c.toPort === portId);
+    if (connection) {
+      return nodeData[`${connection.from}:${connection.fromPort}`];
+    }
+    return undefined;
+  }
+};

package/src/lib/stores/canvas.ts

@@ -0,0 +1,58 @@
+// Re-export the praxis-based canvas store for backward compatibility
+// This maintains the same API while using Praxis reactive engine underneath
+
+import { canvasPraxisStore, canvasPraxisStoreInstance, canvasEngine } from './canvas-praxis';
+import type { Canvas, Connection } from '../types/canvas';
+
+// Use the praxis store from canvas-praxis instead of creating a new one
+const praxisStore = canvasPraxisStoreInstance;
+
+// Create a derived store for just the canvas
+export const canvasStore = {
+  subscribe: (fn: (value: Canvas) => void) => {
+    return praxisStore.subscribe((state) => {
+      fn(state.context.canvas);
+    });
+  },
+  set: (canvas: Canvas) => canvasPraxisStore.loadCanvas(canvas),
+  addNode: canvasPraxisStore.addNode,
+  removeNode: canvasPraxisStore.removeNode,
+  updateNode: canvasPraxisStore.updateNode,
+  updateNodePosition: canvasPraxisStore.updateNodePosition,
+  addConnection: canvasPraxisStore.addConnection,
+  removeConnection: canvasPraxisStore.removeConnection,
+  loadCanvas: canvasPraxisStore.loadCanvas,
+  clear: canvasPraxisStore.clear
+};
+
+// Create a derived store for node data
+export const nodeDataStore = {
+  subscribe: (fn: (value: Record<string, any>) => void) => {
+    return praxisStore.subscribe((state) => {
+      fn(state.context.nodeData);
+    });
+  },
+  set: (data: Record<string, any>) => {
+    // Not typically used, but provided for compatibility
+    const context = canvasEngine.getContext();
+    context.nodeData = data;
+  },
+  update: (fn: (value: Record<string, any>) => Record<string, any>) => {
+    const context = canvasEngine.getContext();
+    context.nodeData = fn(context.nodeData);
+  }
+};
+
+// Helper to update node output data
+export function updateNodeData(nodeId: string, portId: string, data: any) {
+  canvasPraxisStore.updateNodeData(nodeId, portId, data);
+}
+
+// Helper to get node input data from connections
+export function getNodeInputData(nodeId: string, portId: string, connections: Connection[], nodeData: Record<string, any>) {
+  const connection = connections.find(c => c.to === nodeId && c.toPort === portId);
+  if (connection) {
+    return nodeData[`${connection.from}:${connection.fromPort}`];
+  }
+  return undefined;
+}

package/src/lib/types/agent.ts

@@ -0,0 +1,78 @@
+// Types for Ambient Agent Mode (term-agent capabilities)
+
+export interface TerminalEvent {
+  id: string;
+  timestamp: number;
+  command: string;
+  args: string[];
+  env: Record<string, string>;
+  cwd: string;
+  stdout?: string;
+  stderr?: string;
+  exitCode?: number;
+  duration?: number; // milliseconds
+  success: boolean;
+  context?: EventContext;
+}
+
+export interface EventContext {
+  sessionId: string;
+  workingDirectory: string;
+  environment: Record<string, string>;
+  previousCommand?: string;
+  canvasId?: string;
+  nodeId?: string;
+}
+
+export interface CommandPattern {
+  id: string;
+  command: string;
+  frequency: number;
+  lastUsed: number;
+  successRate: number;
+  avgDuration: number;
+  commonArgs: string[];
+  commonEnv: Record<string, string>;
+}
+
+export interface Suggestion {
+  id: string;
+  type: 'command' | 'optimization' | 'shortcut' | 'warning' | 'tip';
+  priority: 'low' | 'medium' | 'high';
+  title: string;
+  description: string;
+  command?: string;
+  args?: string[];
+  context?: Record<string, any>;
+  timestamp: number;
+}
+
+import type { LLMProviderConfig } from '../agent/llm/types';
+
+export interface EventStorage {
+  saveEvent(event: TerminalEvent): Promise<void>;
+  getEvents(limit?: number, since?: number): Promise<TerminalEvent[]>;
+  getEventsByCommand(command: string, limit: number): Promise<TerminalEvent[]>;
+  getPatterns(): Promise<CommandPattern[]>;
+  savePattern(pattern: CommandPattern): Promise<void>;
+  saveSuggestion(suggestion: Suggestion): Promise<void>;
+  getSuggestions(limit: number): Promise<Suggestion[]>;
+  getStats(): Promise<{
+    totalEvents: number;
+    uniqueCommands: number;
+    avgSuccessRate: number;
+    totalDuration: number;
+  }>;
+}
+
+export interface AgentConfig {
+  enabled: boolean;
+  captureEvents: boolean;
+  analyzePatterns: boolean;
+  suggestImprovements: boolean;
+  storagePath?: string;
+  maxEvents?: number;
+  retentionDays?: number;
+  llm?: LLMProviderConfig; // LLM/MCP integration config (disabled by default)
+}
+

package/src/lib/types/canvas.ts

@@ -0,0 +1,71 @@
+// Canvas node types for RuneBook
+export type NodeType = 'terminal' | 'input' | 'display' | 'transform';
+
+export interface Position {
+  x: number;
+  y: number;
+}
+
+export interface Connection {
+  from: string; // Source node ID
+  to: string; // Target node ID
+  fromPort: string; // Output port name
+  toPort: string; // Input port name
+}
+
+export interface Port {
+  id: string;
+  name: string;
+  type: 'input' | 'output';
+  dataType?: string;
+}
+
+export interface BaseNode {
+  id: string;
+  type: NodeType;
+  position: Position;
+  label: string;
+  inputs: Port[];
+  outputs: Port[];
+}
+
+export interface TerminalNode extends BaseNode {
+  type: 'terminal';
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  autoStart?: boolean;
+}
+
+export interface InputNode extends BaseNode {
+  type: 'input';
+  inputType: 'text' | 'number' | 'checkbox' | 'slider';
+  value: any;
+  min?: number;
+  max?: number;
+  step?: number;
+}
+
+export interface DisplayNode extends BaseNode {
+  type: 'display';
+  displayType: 'text' | 'json' | 'table' | 'chart';
+  content: any;
+}
+
+export interface TransformNode extends BaseNode {
+  type: 'transform';
+  transformType: 'map' | 'filter' | 'reduce' | 'sudolang';
+  code: string;
+}
+
+export type CanvasNode = TerminalNode | InputNode | DisplayNode | TransformNode;
+
+export interface Canvas {
+  id: string;
+  name: string;
+  description?: string;
+  nodes: CanvasNode[];
+  connections: Connection[];
+  version: string;
+}