@plures/praxis 1.0.2 → 1.1.0

package/src/integrations/unum.ts

@@ -1,22 +1,22 @@
 /**
  * Unum Integration
- * 
- * Integration with plures/unum - A modern Svelte binding library for PluresDB 
+ *
+ * Integration with plures/unum - A modern Svelte binding library for PluresDB
  * with full Svelte 5 compatibility. Provides identity and channels support.
- * 
+ *
  * Features:
  * - Svelte 4 & 5 Compatible: Works with both store-based and runes-based reactivity
  * - Type-Safe: Full TypeScript support with proper types
  * - Action-Based: Modern Svelte actions for DOM binding
  * - Store-Based: Writable store implementation for reactive data
  * - Collection Support: Easy handling of PluresDB collections
- * 
+ *
  * @see https://github.com/plures/unum
  */
 
-import type { LogicEngine } from "../core/engine.js";
-import type { PraxisEvent, PraxisFact } from "../core/protocol.js";
-import type { PraxisDB } from "../core/pluresdb/adapter.js";
+import type { LogicEngine } from '../core/engine.js';
+import type { PraxisEvent, PraxisFact } from '../core/protocol.js';
+import type { PraxisDB } from '../core/pluresdb/adapter.js';
 
 /**
  * Unum store interface for reactive PluresDB data
@@ -97,53 +97,53 @@ export interface UnumAdapterConfig {
 
 /**
  * Unum adapter for Praxis engine integration
- * 
+ *
  * Provides identity management and channel-based communication
  * for distributed Praxis applications.
  */
 export interface UnumAdapter {
   /** Current identity */
   identity: UnumIdentity | null;
-  
+
   /** Create or update identity */
   setIdentity(identity: Omit<UnumIdentity, 'id' | 'createdAt'>): Promise<UnumIdentity>;
-  
+
   /** Get identity by ID */
   getIdentity(id: string): Promise<UnumIdentity | null>;
-  
+
   /** Create a new channel */
   createChannel(name: string, members?: string[]): Promise<UnumChannel>;
-  
+
   /** Join an existing channel */
   joinChannel(channelId: string): Promise<UnumChannel>;
-  
+
   /** List available channels */
   listChannels(): Promise<UnumChannel[]>;
-  
+
   /** Broadcast a Praxis event to a channel */
   broadcastEvent(channelId: string, event: PraxisEvent): Promise<void>;
-  
+
   /** Broadcast a Praxis fact to a channel */
   broadcastFact(channelId: string, fact: PraxisFact): Promise<void>;
-  
+
   /** Subscribe to events from a channel */
   subscribeToEvents(channelId: string, handler: (event: PraxisEvent) => void): () => void;
-  
+
   /** Subscribe to facts from a channel */
   subscribeToFacts(channelId: string, handler: (fact: PraxisFact) => void): () => void;
-  
+
   /** Disconnect and cleanup */
   disconnect(): Promise<void>;
 }
 
 /**
  * Create a Unum adapter for Praxis engine integration
- * 
+ *
  * @example
  * ```typescript
  * import { createUnumAdapter } from '@plures/praxis/integrations/unum';
  * import { createInMemoryDB } from '@plures/praxis/integrations/pluresdb';
- * 
+ *
  * const db = createInMemoryDB();
  * const unum = await createUnumAdapter({
  *   db,
@@ -152,10 +152,10 @@ export interface UnumAdapter {
  *   },
  *   realtime: true,
  * });
- * 
+ *
  * // Create a channel
  * const channel = await unum.createChannel('my-channel');
- * 
+ *
  * // Broadcast events to the channel
  * await unum.broadcastEvent(channel.id, myEvent);
  * ```
@@ -163,11 +163,11 @@ export interface UnumAdapter {
 export async function createUnumAdapter(config: UnumAdapterConfig): Promise<UnumAdapter> {
   const { db, realtime = true } = config;
   // syncInterval could be used for periodic sync in a more complete implementation
-  
+
   let currentIdentity: UnumIdentity | null = null;
   const channels = new Map<string, UnumChannel>();
   const subscriptions = new Set<() => void>();
-  
+
   // Set initial identity if provided
   if (config.identity) {
     currentIdentity = {
@@ -177,8 +177,10 @@ export async function createUnumAdapter(config: UnumAdapterConfig): Promise<Unum
     };
     await db.set(`unum/identities/${currentIdentity.id}`, currentIdentity);
   }
-  
-  async function setIdentity(identity: Omit<UnumIdentity, 'id' | 'createdAt'>): Promise<UnumIdentity> {
+
+  async function setIdentity(
+    identity: Omit<UnumIdentity, 'id' | 'createdAt'>
+  ): Promise<UnumIdentity> {
     currentIdentity = {
       ...identity,
       id: generateId(),
@@ -187,11 +189,11 @@ export async function createUnumAdapter(config: UnumAdapterConfig): Promise<Unum
     await db.set(`unum/identities/${currentIdentity.id}`, currentIdentity);
     return currentIdentity;
   }
-  
+
   async function getIdentity(id: string): Promise<UnumIdentity | null> {
-    return await db.get(`unum/identities/${id}`) as UnumIdentity | null;
+    return (await db.get(`unum/identities/${id}`)) as UnumIdentity | null;
   }
-  
+
   async function createChannel(name: string, members?: string[]): Promise<UnumChannel> {
     const channelId = generateId();
     const channelData = {
@@ -201,41 +203,44 @@ export async function createUnumAdapter(config: UnumAdapterConfig): Promise<Unum
       createdAt: Date.now(),
       createdBy: currentIdentity?.id,
     };
-    
+
     await db.set(`unum/channels/${channelId}`, channelData);
-    
+
     const channel = createChannelInstance(channelId, name);
     channels.set(channelId, channel);
     return channel;
   }
-  
+
   async function joinChannel(channelId: string): Promise<UnumChannel> {
     const existing = channels.get(channelId);
     if (existing) return existing;
-    
-    const channelData = await db.get(`unum/channels/${channelId}`) as { id: string; name: string } | null;
+
+    const channelData = (await db.get(`unum/channels/${channelId}`)) as {
+      id: string;
+      name: string;
+    } | null;
     if (!channelData) {
       throw new Error(`Channel ${channelId} not found`);
     }
-    
+
     const channel = createChannelInstance(channelData.id, channelData.name);
     channels.set(channelId, channel);
     return channel;
   }
-  
+
   async function listChannels(): Promise<UnumChannel[]> {
     return Array.from(channels.values());
   }
-  
+
   function createChannelInstance(id: string, name: string): UnumChannel {
     const handlers = new Set<(message: UnumMessage) => void>();
-    
+
     return {
       id,
       name,
       subscribe(handler: (message: UnumMessage) => void): () => void {
         handlers.add(handler);
-        
+
         // Set up database subscription if realtime is enabled
         if (realtime) {
           const unsub = db.watch(`unum/channels/${id}/messages`, (data) => {
@@ -245,7 +250,7 @@ export async function createUnumAdapter(config: UnumAdapterConfig): Promise<Unum
           });
           subscriptions.add(unsub);
         }
-        
+
         return () => {
           handlers.delete(handler);
         };
@@ -257,16 +262,16 @@ export async function createUnumAdapter(config: UnumAdapterConfig): Promise<Unum
           channelId: id,
           timestamp: Date.now(),
         };
-        
+
         await db.set(`unum/channels/${id}/messages/${fullMessage.id}`, fullMessage);
-        
+
         // Notify local handlers
-        handlers.forEach(h => h(fullMessage));
+        handlers.forEach((h) => h(fullMessage));
       },
       async getMembers(): Promise<UnumIdentity[]> {
-        const channelData = await db.get(`unum/channels/${id}`) as { members?: string[] } | null;
+        const channelData = (await db.get(`unum/channels/${id}`)) as { members?: string[] } | null;
         if (!channelData?.members) return [];
-        
+
         const members: UnumIdentity[] = [];
         for (const memberId of channelData.members) {
           const identity = await getIdentity(memberId);
@@ -279,13 +284,13 @@ export async function createUnumAdapter(config: UnumAdapterConfig): Promise<Unum
       },
     };
   }
-  
+
   async function broadcastEvent(channelId: string, event: PraxisEvent): Promise<void> {
     const channel = channels.get(channelId);
     if (!channel) {
       throw new Error(`Not joined to channel ${channelId}`);
     }
-    
+
     await channel.publish({
       id: generateId(),
       sender: currentIdentity || { id: 'anonymous', createdAt: Date.now() },
@@ -293,13 +298,13 @@ export async function createUnumAdapter(config: UnumAdapterConfig): Promise<Unum
       type: 'event',
     });
   }
-  
+
   async function broadcastFact(channelId: string, fact: PraxisFact): Promise<void> {
     const channel = channels.get(channelId);
     if (!channel) {
       throw new Error(`Not joined to channel ${channelId}`);
     }
-    
+
     await channel.publish({
       id: generateId(),
       sender: currentIdentity || { id: 'anonymous', createdAt: Date.now() },
@@ -307,49 +312,51 @@ export async function createUnumAdapter(config: UnumAdapterConfig): Promise<Unum
       type: 'fact',
     });
   }
-  
+
   function subscribeToEvents(channelId: string, handler: (event: PraxisEvent) => void): () => void {
     const channel = channels.get(channelId);
     if (!channel) {
       throw new Error(`Not joined to channel ${channelId}`);
     }
-    
+
     return channel.subscribe((message) => {
       if (message.type === 'event') {
         handler(message.content as PraxisEvent);
       }
     });
   }
-  
+
   function subscribeToFacts(channelId: string, handler: (fact: PraxisFact) => void): () => void {
     const channel = channels.get(channelId);
     if (!channel) {
       throw new Error(`Not joined to channel ${channelId}`);
     }
-    
+
     return channel.subscribe((message) => {
       if (message.type === 'fact') {
         handler(message.content as PraxisFact);
       }
     });
   }
-  
+
   async function disconnect(): Promise<void> {
     // Cleanup all subscriptions
-    subscriptions.forEach(unsub => unsub());
+    subscriptions.forEach((unsub) => unsub());
     subscriptions.clear();
-    
+
     // Leave all channels
     for (const channel of channels.values()) {
       await channel.leave();
     }
     channels.clear();
-    
+
     currentIdentity = null;
   }
-  
+
   return {
-    get identity() { return currentIdentity; },
+    get identity() {
+      return currentIdentity;
+    },
     setIdentity,
     getIdentity,
     createChannel,
@@ -372,11 +379,11 @@ function generateId(): string {
 
 /**
  * Attach Unum adapter to a Praxis engine
- * 
+ *
  * Enables automatic event/fact broadcasting to connected channels.
  * This is a placeholder for future integration where the engine
  * would emit events that get broadcast to channels.
- * 
+ *
  * @param _engine - The Praxis logic engine
  * @param _adapter - The Unum adapter
  * @param _channelId - The channel to broadcast to

package/src/registry.ts

@@ -9,10 +9,7 @@ import type { Rule, Constraint, ConstraintViolation } from './dsl.js';
 /**
  * Registry for managing rules and constraints.
  */
-export class Registry<
-  S extends PraxisState = PraxisState,
-  E extends PraxisEvent = PraxisEvent
-> {
+export class Registry<S extends PraxisState = PraxisState, E extends PraxisEvent = PraxisEvent> {
   private rules: Map<string, Rule<S, E>> = new Map();
   private constraints: Map<string, Constraint<S>> = new Map();
 
@@ -113,14 +110,12 @@ export class Registry<
    */
   evaluateRules(state: S, event: E): Effect[] {
     const effects: Effect[] = [];
-    
+
     // Get rules that match the event type
     const applicableRules = this.getRulesForEvent(event.type);
-    
+
     // Sort by priority (higher priority first)
-    const sortedRules = applicableRules.sort(
-      (a, b) => (b.priority ?? 0) - (a.priority ?? 0)
-    );
+    const sortedRules = applicableRules.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
 
     // Evaluate each rule
     for (const rule of sortedRules) {
@@ -149,9 +144,7 @@ export class Registry<
         if (!constraint.check(state)) {
           violations.push({
             constraintId: constraint.id,
-            message:
-              constraint.errorMessage ||
-              `Constraint '${constraint.id}' violated`,
+            message: constraint.errorMessage || `Constraint '${constraint.id}' violated`,
             state,
           });
         }
@@ -198,7 +191,7 @@ export class Registry<
     rulesByEventType: Record<string, number>;
   } {
     const rulesByEventType: Record<string, number> = {};
-    
+
     for (const rule of this.rules.values()) {
       const eventType = rule.eventType || '*';
       rulesByEventType[eventType] = (rulesByEventType[eventType] || 0) + 1;
@@ -217,7 +210,7 @@ export class Registry<
  */
 export function createRegistry<
   S extends PraxisState = PraxisState,
-  E extends PraxisEvent = PraxisEvent
+  E extends PraxisEvent = PraxisEvent,
 >(): Registry<S, E> {
   return new Registry<S, E>();
 }

package/src/runtime/terminal-adapter.ts

@@ -1,6 +1,6 @@
 /**
  * Terminal Node Runtime Adapter
- * 
+ *
  * Handles terminal command execution and state management.
  * Integrates with pluresDB for state synchronization.
  */
@@ -82,23 +82,28 @@ async function defaultExecutor(
     const { exec } = await import('child_process');
     const { promisify } = await import('util');
     const execAsync = promisify(exec);
-    
+
     // Get process.env safely (only available in Node.js environments)
-    const processEnv = typeof process !== "undefined" ? process.env : {};
-    
+    const processEnv = typeof process !== 'undefined' ? process.env : {};
+
     const result = await execAsync(command, {
       cwd: options.cwd,
       env: { ...processEnv, ...options.env },
       maxBuffer: 10 * 1024 * 1024, // 10MB buffer
       timeout: 60000, // 60 second timeout
     });
-    
+
     return {
       output: result.stdout + (result.stderr ? `\n${result.stderr}` : ''),
       exitCode: 0,
     };
   } catch (error: unknown) {
-    const execError = error as { stdout?: string; stderr?: string; code?: number; message?: string };
+    const execError = error as {
+      stdout?: string;
+      stderr?: string;
+      code?: number;
+      message?: string;
+    };
     return {
       output: (execError.stdout || '') + (execError.stderr || ''),
       exitCode: execError.code || 1,
@@ -109,7 +114,7 @@ async function defaultExecutor(
 
 /**
  * Terminal Runtime Adapter
- * 
+ *
  * Manages terminal node execution and state.
  * Supports command execution with history tracking and PluresDB integration.
  */
@@ -137,22 +142,22 @@ export class TerminalAdapter {
 
   /**
    * Execute a terminal command
-   * 
+   *
    * @param command - Command to execute
    * @returns Execution result
    */
   async executeCommand(command: string): Promise<TerminalExecutionResult> {
     // Add to history
     this.state.history.push(command);
-    
+
     const timestamp = Date.now();
-    
+
     // Execute the command
     const { output, exitCode, error } = await this.executor(command, {
       cwd: this.state.cwd,
       env: this.state.env,
     });
-    
+
     const result: TerminalExecutionResult = {
       command,
       output,
@@ -219,13 +224,13 @@ export class TerminalAdapter {
 
   /**
    * Sync state to PluresDB
-   * 
+   *
    * @param path - PluresDB path for storing results
    * @param data - Data to sync
    */
   private async syncToPluresDB(path: string, data: TerminalExecutionResult): Promise<void> {
     if (!this.db) return;
-    
+
     try {
       // Store the execution result
       await this.db.set(path, {
@@ -233,7 +238,7 @@ export class TerminalAdapter {
         nodeId: this.state.nodeId,
         syncedAt: Date.now(),
       });
-      
+
       // Also append to history path
       const historyPath = `${path}/history`;
       const historyKey = `${historyPath}/${data.timestamp}`;
@@ -248,7 +253,7 @@ export class TerminalAdapter {
    */
   async loadFromPluresDB(): Promise<void> {
     if (!this.db || !this.inputPath) return;
-    
+
     try {
       const data = await this.db.get(this.inputPath);
       if (data && typeof data === 'object') {
@@ -276,7 +281,7 @@ export class TerminalAdapter {
    */
   watchInput(callback: (command: string) => void): (() => void) | null {
     if (!this.db || !this.inputPath) return null;
-    
+
     return this.db.watch(this.inputPath, (data) => {
       if (data && typeof data === 'object' && 'command' in data) {
         callback((data as { command: string }).command);
@@ -287,19 +292,17 @@ export class TerminalAdapter {
 
 /**
  * Create a terminal adapter instance
- * 
+ *
  * @param options - Terminal adapter options
  * @returns Terminal adapter instance
  */
-export function createTerminalAdapter(
-  options: TerminalAdapterOptions
-): TerminalAdapter {
+export function createTerminalAdapter(options: TerminalAdapterOptions): TerminalAdapter {
   return new TerminalAdapter(options);
 }
 
 /**
  * Run a terminal command (convenience function)
- * 
+ *
  * @param nodeId - Terminal node identifier
  * @param command - Command to execute
  * @param options - Additional options
@@ -308,13 +311,14 @@ export function createTerminalAdapter(
 export async function runTerminalCommand(
   nodeId: string,
   command: string,
-  options?: { cwd?: string; env?: Record<string, string>; db?: PraxisDB }
+  options?: { cwd?: string; env?: Record<string, string>; db?: PraxisDB; executor?: CommandExecutor }
 ): Promise<TerminalExecutionResult> {
   const adapter = createTerminalAdapter({
     nodeId,
     cwd: options?.cwd,
     env: options?.env,
     db: options?.db,
+    executor: options?.executor,
   });
   return adapter.executeCommand(command);
 }
@@ -327,10 +331,11 @@ export function createMockExecutor(
   responses: Record<string, { output: string; exitCode: number; error?: string }>
 ): CommandExecutor {
   return async (command: string) => {
-    const response = responses[command] || responses['*'] || {
-      output: `Mock output for: ${command}`,
-      exitCode: 0,
-    };
+    const response = responses[command] ||
+      responses['*'] || {
+        output: `Mock output for: ${command}`,
+        exitCode: 0,
+      };
     return response;
   };
 }

package/src/step.ts

@@ -11,7 +11,7 @@ import type { Registry } from './registry.js';
  */
 export interface StepOptions<
   S extends PraxisState = PraxisState,
-  E extends PraxisEvent = PraxisEvent
+  E extends PraxisEvent = PraxisEvent,
 > {
   /** Registry containing rules and constraints */
   registry?: Registry<S, E>;
@@ -27,7 +27,7 @@ export interface StepOptions<
  */
 export function createStepFunction<
   S extends PraxisState = PraxisState,
-  E extends PraxisEvent = PraxisEvent
+  E extends PraxisEvent = PraxisEvent,
 >(options: StepOptions<S, E> = {}): StepFunction<S, E> {
   const { registry, checkConstraints = true, reducer } = options;
 
@@ -38,9 +38,7 @@ export function createStepFunction<
     if (checkConstraints && registry) {
       const violations = registry.checkConstraints(state);
       if (violations.length > 0) {
-        errors.push(
-          ...violations.map((v) => `Pre-condition: ${v.message}`)
-        );
+        errors.push(...violations.map((v) => `Pre-condition: ${v.message}`));
         // Return current state with errors
         return { state, errors };
       }
@@ -78,9 +76,7 @@ export function createStepFunction<
     if (checkConstraints && registry) {
       const violations = registry.checkConstraints(newState);
       if (violations.length > 0) {
-        errors.push(
-          ...violations.map((v) => `Post-condition: ${v.message}`)
-        );
+        errors.push(...violations.map((v) => `Post-condition: ${v.message}`));
         // Return previous state with errors to maintain invariants
         return { state, errors };
       }
@@ -98,10 +94,9 @@ export function createStepFunction<
  * Simple step function that just applies a reducer.
  * Useful for basic state transitions without rules or constraints.
  */
-export function step<
-  S extends PraxisState = PraxisState,
-  E extends PraxisEvent = PraxisEvent
->(reducer: (state: S, event: E) => S): StepFunction<S, E> {
+export function step<S extends PraxisState = PraxisState, E extends PraxisEvent = PraxisEvent>(
+  reducer: (state: S, event: E) => S
+): StepFunction<S, E> {
   return (state: S, event: E): StepResult<S> => {
     try {
       const newState = reducer(state, event);
@@ -120,10 +115,9 @@ export function step<
  * Each step function is applied in sequence, with the output of one
  * becoming the input to the next.
  */
-export function compose<
-  S extends PraxisState = PraxisState,
-  E extends PraxisEvent = PraxisEvent
->(...steps: StepFunction<S, E>[]): StepFunction<S, E> {
+export function compose<S extends PraxisState = PraxisState, E extends PraxisEvent = PraxisEvent>(
+  ...steps: StepFunction<S, E>[]
+): StepFunction<S, E> {
   return (state: S, event: E): StepResult<S> => {
     let currentState = state;
     const allEffects: StepResult<S>['effects'] = [];

package/src/types.ts

@@ -66,5 +66,5 @@ export interface Effect {
  */
 export type StepFunction<
   S extends PraxisState = PraxisState,
-  E extends PraxisEvent = PraxisEvent
+  E extends PraxisEvent = PraxisEvent,
 > = (state: S, event: E) => StepResult<S>;