@plures/praxis 0.2.1 → 1.0.1

package/src/integrations/unum.ts

@@ -0,0 +1,395 @@
+/**
+ * Unum Integration
+ * 
+ * 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";
+
+/**
+ * Unum store interface for reactive PluresDB data
+ */
+export interface UnumStore<T> {
+  subscribe(run: (value: T) => void): () => void;
+  set(value: T): void;
+  update(updater: (value: T) => T): void;
+}
+
+/**
+ * Unum channel for real-time communication
+ */
+export interface UnumChannel {
+  /** Channel identifier */
+  id: string;
+  /** Channel name */
+  name: string;
+  /** Subscribe to channel messages */
+  subscribe(handler: (message: UnumMessage) => void): () => void;
+  /** Publish a message to the channel */
+  publish(message: Omit<UnumMessage, 'timestamp' | 'channelId'>): Promise<void>;
+  /** Get channel members */
+  getMembers(): Promise<UnumIdentity[]>;
+  /** Leave the channel */
+  leave(): Promise<void>;
+}
+
+/**
+ * Message sent through a Unum channel
+ */
+export interface UnumMessage {
+  /** Message ID */
+  id: string;
+  /** Channel ID */
+  channelId: string;
+  /** Sender identity */
+  sender: UnumIdentity;
+  /** Message content */
+  content: unknown;
+  /** Message type */
+  type: 'text' | 'event' | 'fact' | 'system';
+  /** Timestamp */
+  timestamp: number;
+}
+
+/**
+ * Unum identity representing a user or system
+ */
+export interface UnumIdentity {
+  /** Unique identifier */
+  id: string;
+  /** Display name */
+  name?: string;
+  /** Public key for encryption */
+  publicKey?: string;
+  /** Identity metadata */
+  metadata?: Record<string, unknown>;
+  /** Creation timestamp */
+  createdAt: number;
+  /** Last seen timestamp */
+  lastSeen?: number;
+}
+
+/**
+ * Unum adapter configuration
+ */
+export interface UnumAdapterConfig {
+  /** PluresDB instance to use */
+  db: PraxisDB;
+  /** Current user identity */
+  identity?: UnumIdentity;
+  /** Whether to enable real-time sync */
+  realtime?: boolean;
+  /** Sync interval in milliseconds */
+  syncInterval?: number;
+}
+
+/**
+ * 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,
+ *   identity: {
+ *     name: 'Alice',
+ *   },
+ *   realtime: true,
+ * });
+ * 
+ * // Create a channel
+ * const channel = await unum.createChannel('my-channel');
+ * 
+ * // Broadcast events to the channel
+ * await unum.broadcastEvent(channel.id, myEvent);
+ * ```
+ */
+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 = {
+      ...config.identity,
+      id: config.identity.id || generateId(),
+      createdAt: Date.now(),
+    };
+    await db.set(`unum/identities/${currentIdentity.id}`, currentIdentity);
+  }
+  
+  async function setIdentity(identity: Omit<UnumIdentity, 'id' | 'createdAt'>): Promise<UnumIdentity> {
+    currentIdentity = {
+      ...identity,
+      id: generateId(),
+      createdAt: Date.now(),
+    };
+    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;
+  }
+  
+  async function createChannel(name: string, members?: string[]): Promise<UnumChannel> {
+    const channelId = generateId();
+    const channelData = {
+      id: channelId,
+      name,
+      members: members || [],
+      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;
+    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) => {
+            if (data) {
+              handler(data as UnumMessage);
+            }
+          });
+          subscriptions.add(unsub);
+        }
+        
+        return () => {
+          handlers.delete(handler);
+        };
+      },
+      async publish(message: Omit<UnumMessage, 'timestamp' | 'channelId'>): Promise<void> {
+        const fullMessage: UnumMessage = {
+          ...message,
+          id: message.id || generateId(),
+          channelId: id,
+          timestamp: Date.now(),
+        };
+        
+        await db.set(`unum/channels/${id}/messages/${fullMessage.id}`, fullMessage);
+        
+        // Notify local handlers
+        handlers.forEach(h => h(fullMessage));
+      },
+      async getMembers(): Promise<UnumIdentity[]> {
+        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);
+          if (identity) members.push(identity);
+        }
+        return members;
+      },
+      async leave(): Promise<void> {
+        channels.delete(id);
+      },
+    };
+  }
+  
+  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() },
+      content: event,
+      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() },
+      content: fact,
+      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.clear();
+    
+    // Leave all channels
+    for (const channel of channels.values()) {
+      await channel.leave();
+    }
+    channels.clear();
+    
+    currentIdentity = null;
+  }
+  
+  return {
+    get identity() { return currentIdentity; },
+    setIdentity,
+    getIdentity,
+    createChannel,
+    joinChannel,
+    listChannels,
+    broadcastEvent,
+    broadcastFact,
+    subscribeToEvents,
+    subscribeToFacts,
+    disconnect,
+  };
+}
+
+/**
+ * Generate a unique ID
+ */
+function generateId(): string {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+/**
+ * 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
+ * @returns Cleanup function
+ */
+export function attachUnumToEngine<TContext>(
+  _engine: LogicEngine<TContext>,
+  _adapter: UnumAdapter,
+  _channelId: string
+): () => void {
+  // In a future implementation, this would:
+  // 1. Hook into engine state changes
+  // 2. Broadcast new events/facts to the channel
+  // For now, return a no-op cleanup function
+  return () => {};
+}

package/src/runtime/terminal-adapter.ts

@@ -5,7 +5,11 @@
  * Integrates with pluresDB for state synchronization.
  */
 
+// Declare process for TypeScript in non-Node environments (e.g., Deno)
+declare const process: { env: { [key: string]: string | undefined } } | undefined;
+
 import type { TerminalNodeProps } from '../core/schema/types.js';
+import type { PraxisDB } from '../core/pluresdb/adapter.js';
 
 /**
  * Terminal command execution result
@@ -47,19 +51,74 @@ export interface TerminalAdapterOptions {
   inputPath?: string;
   /** PluresDB path for output binding */
   outputPath?: string;
+  /** Current working directory */
+  cwd?: string;
+  /** Environment variables */
+  env?: Record<string, string>;
+  /** PluresDB instance for state persistence */
+  db?: PraxisDB;
+  /** Command executor function (for custom execution environments) */
+  executor?: CommandExecutor;
+}
+
+/**
+ * Command executor function type
+ */
+export type CommandExecutor = (
+  command: string,
+  options: { cwd?: string; env?: Record<string, string> }
+) => Promise<{ output: string; exitCode: number; error?: string }>;
+
+/**
+ * Default command executor using child_process
+ * Note: This only works in Node.js environments
+ */
+async function defaultExecutor(
+  command: string,
+  options: { cwd?: string; env?: Record<string, string> }
+): Promise<{ output: string; exitCode: number; error?: string }> {
+  try {
+    // Dynamic import to support environments without child_process
+    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 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 };
+    return {
+      output: (execError.stdout || '') + (execError.stderr || ''),
+      exitCode: execError.code || 1,
+      error: execError.message || 'Command execution failed',
+    };
+  }
 }
 
 /**
  * Terminal Runtime Adapter
  * 
  * Manages terminal node execution and state.
- * 
- * Note: PluresDB input/output path bindings will be implemented
- * when pluresDB integration is complete.
+ * Supports command execution with history tracking and PluresDB integration.
  */
 export class TerminalAdapter {
   private state: TerminalNodeState;
+  private inputPath?: string;
   private outputPath?: string;
+  private db?: PraxisDB;
+  private executor: CommandExecutor;
 
   constructor(options: TerminalAdapterOptions) {
     this.state = {
@@ -67,10 +126,13 @@ export class TerminalAdapter {
       inputMode: options.props?.inputMode || 'text',
       history: options.props?.history || [],
       lastOutput: options.props?.lastOutput || null,
+      cwd: options.cwd,
+      env: options.env,
     };
-    // TODO: Store inputPath when pluresDB integration is complete
-    // const inputPath = options.inputPath;
+    this.inputPath = options.inputPath;
     this.outputPath = options.outputPath;
+    this.db = options.db;
+    this.executor = options.executor || defaultExecutor;
   }
 
   /**
@@ -82,21 +144,28 @@ export class TerminalAdapter {
   async executeCommand(command: string): Promise<TerminalExecutionResult> {
     // Add to history
     this.state.history.push(command);
-
-    // TODO: Integrate with RuneBook execution model
-    // For now, return a stubbed response
+    
+    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: `[Stub] Command received: ${command}\nIntegration with RuneBook pending.`,
-      exitCode: 0,
-      timestamp: Date.now(),
+      output,
+      exitCode,
+      timestamp,
+      error,
     };
 
     // Update last output
-    this.state.lastOutput = result.output;
+    this.state.lastOutput = output;
 
-    // TODO: Sync to pluresDB output path when integration is available
-    if (this.outputPath) {
+    // Sync to PluresDB if configured
+    if (this.db && this.outputPath) {
       await this.syncToPluresDB(this.outputPath, result);
     }
 
@@ -120,6 +189,20 @@ export class TerminalAdapter {
     };
   }
 
+  /**
+   * Set working directory
+   */
+  setCwd(cwd: string): void {
+    this.state.cwd = cwd;
+  }
+
+  /**
+   * Set environment variables
+   */
+  setEnv(env: Record<string, string>): void {
+    this.state.env = { ...this.state.env, ...env };
+  }
+
   /**
    * Clear command history
    */
@@ -135,15 +218,70 @@ export class TerminalAdapter {
   }
 
   /**
-   * Sync state to pluresDB (placeholder)
+   * Sync state to PluresDB
    * 
-   * @param _path - PluresDB path (unused until integration is complete)
-   * @param _data - Data to sync (unused until integration is complete)
+   * @param path - PluresDB path for storing results
+   * @param data - Data to sync
    */
-  private async syncToPluresDB(_path: string, _data: unknown): Promise<void> {
-    // TODO: Implement pluresDB sync when integration is available
-    // When implemented, this will sync terminal output to the specified pluresDB path
-    // for reactive state management across the application
+  private async syncToPluresDB(path: string, data: TerminalExecutionResult): Promise<void> {
+    if (!this.db) return;
+    
+    try {
+      // Store the execution result
+      await this.db.set(path, {
+        ...data,
+        nodeId: this.state.nodeId,
+        syncedAt: Date.now(),
+      });
+      
+      // Also append to history path
+      const historyPath = `${path}/history`;
+      const historyKey = `${historyPath}/${data.timestamp}`;
+      await this.db.set(historyKey, data);
+    } catch (error) {
+      console.warn('Failed to sync to PluresDB:', error);
+    }
+  }
+
+  /**
+   * Load state from PluresDB
+   */
+  async loadFromPluresDB(): Promise<void> {
+    if (!this.db || !this.inputPath) return;
+    
+    try {
+      const data = await this.db.get(this.inputPath);
+      if (data && typeof data === 'object') {
+        const savedState = data as Partial<TerminalNodeState>;
+        if (savedState.history) {
+          this.state.history = savedState.history;
+        }
+        if (savedState.lastOutput !== undefined) {
+          this.state.lastOutput = savedState.lastOutput;
+        }
+        if (savedState.cwd) {
+          this.state.cwd = savedState.cwd;
+        }
+        if (savedState.env) {
+          this.state.env = savedState.env;
+        }
+      }
+    } catch (error) {
+      console.warn('Failed to load from PluresDB:', error);
+    }
+  }
+
+  /**
+   * Subscribe to input changes from PluresDB
+   */
+  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);
+      }
+    });
   }
 }
 
@@ -164,12 +302,35 @@ export function createTerminalAdapter(
  * 
  * @param nodeId - Terminal node identifier
  * @param command - Command to execute
+ * @param options - Additional options
  * @returns Execution result
  */
 export async function runTerminalCommand(
   nodeId: string,
-  command: string
+  command: string,
+  options?: { cwd?: string; env?: Record<string, string>; db?: PraxisDB }
 ): Promise<TerminalExecutionResult> {
-  const adapter = createTerminalAdapter({ nodeId });
+  const adapter = createTerminalAdapter({
+    nodeId,
+    cwd: options?.cwd,
+    env: options?.env,
+    db: options?.db,
+  });
   return adapter.executeCommand(command);
 }
+
+/**
+ * Create a mock executor for testing
+ * Returns a function that returns predefined outputs
+ */
+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,
+    };
+    return response;
+  };
+}

package/dist/adapters/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/adapters/cli.ts"],"names":[],"mappings":";AACA;;;;;;;GAOG;AAGH,OAAO,EAEL,cAAc,EACd,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EAGtB,MAAM,aAAa,CAAC;AAErB,UAAU,QAAQ;IAChB,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,cAAc;IACtB,KAAK,EAAE,KAAK,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,WAAW,EAAE,MAAM,CAAC;QAEpB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;IACH,WAAW,EAAE,KAAK,CAAC;QACjB,EAAE,EAAE,MAAM,CAAC;QACX,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,iBAAS,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,CAO9D;AAED;;;;GAIG;AACH,iBAAS,wBAAwB,CAAC,QAAQ,GAAG,OAAO,EAClD,MAAM,EAAE,cAAc,GACrB,cAAc,CAAC,QAAQ,CAAC,CAgD1B;AAED;;GAEG;AACH,iBAAS,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,gBAAgB,CAetD;AA8CD,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/adapters/cli.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/adapters/cli.ts"],"names":[],"mappings":"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"}

package/dist/cli/commands/auth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/auth.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAqEH;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAoG7E;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAcnD;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CA4DnD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,MAAM,GAAG,IAAI,CAG5C"}