@miller-tech/uap 2.36.1 → 2.39.0

package/examples/auto-coordinator-example.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * Auto-Coordinator Example
+ *
+ * Demonstrates automatic agent registration and multi-agent coordination.
+ *
+ * Usage:
+ *   node examples/auto-coordinator-example.js
+ */
+
+import { createAutoAgent } from '../src/coordination/auto-agent.js';
+import { TaskService } from '../src/tasks/service.js';
+import { TaskCoordinator } from '../src/tasks/coordination.js';
+
+async function main() {
+  console.log('=== Multi-Agent Coordination Example ===\n');
+
+  // Example 1: Create an auto-agent
+  console.log('1. Creating auto-agent with automatic registration...');
+  const autoAgent = createAutoAgent({
+    name: 'dev-agent-1',
+    capabilities: ['coding', 'testing', 'review'],
+    worktreeBranch: 'feature/new-dashboard',
+    heartbeatIntervalMs: 30000,
+  });
+
+  const result = await autoAgent.start();
+  console.log(`   ✓ Agent registered: ${result.agent.id}`);
+  console.log(`   ✓ Agent name: ${result.agent.name}`);
+  console.log(`   ✓ Status: ${result.agent.status}`);
+  console.log(`   ✓ Worktree: ${result.agent.worktreeBranch}\n`);
+
+  // Example 2: Announce work on a resource
+  console.log('2. Announcing work on resource...');
+  const announcementResult = autoAgent.announceWork('src/components/Dashboard.tsx', 'editing', {
+    description: 'Implementing new dashboard component',
+    filesAffected: ['src/components/Dashboard.tsx', 'src/types/dashboard.ts'],
+    estimatedMinutes: 120,
+  });
+  console.log(`   ✓ Announced: ${announcementResult.announcement.resource}`);
+  console.log(`   ✓ Intent: ${announcementResult.announcement.intentType}`);
+  console.log(`   ✓ Overlaps detected: ${announcementResult.overlaps.length}\n`);
+
+  // Example 3: Check for overlaps
+  console.log('3. Checking for overlaps...');
+  const overlaps = autoAgent.checkOverlaps('src/components/Dashboard.tsx');
+  if (overlaps.length > 0) {
+    console.log(`   ⚠️  Found ${overlaps.length} overlap(s):`);
+    for (const overlap of overlaps) {
+      console.log(`      - ${overlap.conflictRisk}: ${overlap.agents.length} agents`);
+    }
+  } else {
+    console.log('   ✓ No overlaps detected\n');
+  }
+
+  // Example 4: Integrate with task coordination
+  console.log('4. Integrating with task coordination...');
+  const taskService = new TaskService();
+  const taskCoordinator = new TaskCoordinator({
+    taskService,
+    coordinationService: autoAgent.getService(),
+    agentId: autoAgent.getAgentId(),
+    agentName: autoAgent.getAgentId().slice(0, 8),
+    worktreeBranch: 'feature/new-dashboard',
+  });
+
+  // Suggest next task
+  const suggestedTask = taskCoordinator.suggestNextTask();
+  if (suggestedTask) {
+    console.log(
+      `   ✓ Suggested task: ${suggestedTask.title} (Priority: ${suggestedTask.priority})`
+    );
+  } else {
+    console.log('   ✓ No ready tasks found\n');
+  }
+
+  // Example 5: Claim a task with coordination
+  console.log('5. Claiming task with coordination...');
+  try {
+    // First, create a test task
+    const testTask = taskService.create({
+      title: 'Test Task for Coordination',
+      type: 'task',
+      priority: 1,
+      labels: ['coordination', 'test'],
+    });
+
+    // Claim it
+    const claimResult = await taskCoordinator.claim(testTask.id);
+    if (claimResult) {
+      console.log(`   ✓ Task claimed: ${claimResult.task.title}`);
+      console.log(`   ✓ Worktree: ${claimResult.worktreeBranch}`);
+      console.log(`   ✓ Announced work to coordination system`);
+    }
+  } catch (error) {
+    console.log(`   ⚠️  Could not claim task: ${error.message}`);
+  }
+
+  // Example 6: Simulate another agent
+  console.log('\n6. Simulating second agent...');
+  const autoAgent2 = createAutoAgent({
+    name: 'dev-agent-2',
+    capabilities: ['testing', 'review'],
+    worktreeBranch: 'fix/login-bug',
+  });
+
+  const result2 = await autoAgent2.start();
+  console.log(`   ✓ Agent 2 registered: ${result2.agent.id}`);
+
+  // Announce work on same resource
+  const announcement2 = autoAgent2.announceWork('src/components/Dashboard.tsx', 'reviewing', {
+    description: 'Reviewing dashboard component',
+    estimatedMinutes: 30,
+  });
+  console.log(`   ✓ Agent 2 announced work on same resource`);
+  console.log(`   ✓ Overlaps detected: ${announcement2.overlaps.length}`);
+
+  // Example 7: Cleanup
+  console.log('\n7. Cleaning up agents...');
+  result.cleanup();
+  result2.cleanup();
+  console.log('   ✓ Agents marked as completed');
+
+  console.log('\n=== Example Complete ===');
+}
+
+main().catch(console.error);

package/examples/demo-order-solid.ts

@@ -0,0 +1,19 @@
+/**
+ * Demo script to showcase the SOLID-refactored order processing system.
+ *
+ * Run with: tsx examples/demo-order-solid.ts
+ */
+
+import { runExamples } from './order-solid-refactor.js';
+
+console.log('========================================');
+console.log('SOLID Order Processing System Demo');
+console.log('========================================');
+console.log('');
+
+// Run all examples
+runExamples();
+
+console.log('========================================');
+console.log('Demo Complete');
+console.log('========================================');

package/examples/order-processing-strategy-pattern.ts

@@ -0,0 +1,186 @@
+// ============================================
+// Strategy Pattern: Order Processing Refactor
+// ============================================
+
+// Strategy interface
+interface OrderProcessingStrategy {
+  process(order: Order): Order;
+}
+
+// Order interface for type safety
+interface Order {
+  type: string;
+  status?: string;  // Status is optional, computed during processing
+  [key: string]: any; // Allow additional properties
+}
+
+// ===== Concrete Strategy Implementations =====
+
+class DigitalOrderStrategy implements OrderProcessingStrategy {
+  process(order: Order): Order {
+    // Assume: order is a valid digital order with required fields
+    // Condition: order.type should be 'digital'
+    // Edge case: Order might be null/undefined - we return a new object to maintain immutability
+    return { ...order, status: 'delivered' };
+  }
+}
+
+class PhysicalOrderStrategy implements OrderProcessingStrategy {
+  process(order: Order): Order {
+    // Assume: order is a valid physical order with shipping address
+    // Condition: order.type should be 'physical'
+    return { ...order, status: 'shipped' };
+  }
+}
+
+class SubscriptionOrderStrategy implements OrderProcessingStrategy {
+  process(order: Order): Order {
+    // Assume: order is a valid subscription order with billing info
+    // Condition: order.type should be 'subscription'
+    return { ...order, status: 'active' };
+  }
+}
+
+// Default/fallback strategy for unknown order types
+class DefaultOrderStrategy implements OrderProcessingStrategy {
+  process(order: Order): Order {
+    // Assume: order is valid but type is unknown
+    // Condition: Handles any unrecognized order type gracefully
+    return { ...order, status: 'pending' };
+  }
+}
+
+// ===== Strategy Factory =====
+
+class OrderProcessingStrategyFactory {
+  private strategies: Map<string, OrderProcessingStrategy> = new Map();
+
+  constructor() {
+    // Register default strategies
+    this.registerStrategy('digital', new DigitalOrderStrategy());
+    this.registerStrategy('physical', new PhysicalOrderStrategy());
+    this.registerStrategy('subscription', new SubscriptionOrderStrategy());
+  }
+
+  registerStrategy(type: string, strategy: OrderProcessingStrategy): void {
+    // Assume: type is a non-empty string, strategy is valid
+    // Condition: Adds strategy to registry, overwriting if type exists
+    this.strategies.set(type, strategy);
+  }
+
+  getStrategy(type: string): OrderProcessingStrategy {
+    // Assume: type is a string
+    // Condition: Returns strategy if found, else returns default
+    // Edge case: type might be undefined - handled by returning default
+    return this.strategies.get(type) || new DefaultOrderStrategy();
+  }
+
+  hasStrategy(type: string): boolean {
+    return this.strategies.has(type);
+  }
+}
+
+// ===== Context (Order Processor) =====
+
+class OrderProcessor {
+  private factory: OrderProcessingStrategyFactory;
+
+  constructor(factory?: OrderProcessingStrategyFactory) {
+    // Assume: factory is provided or create default
+    // Condition: Uses dependency injection for testability
+    this.factory = factory || new OrderProcessingStrategyFactory();
+  }
+
+  processOrder(order: Order): Order {
+    // Assume: order is a valid object with at least a 'type' property
+    // Condition: Processes order using appropriate strategy
+    // Edge case: order is undefined/null - we handle defensively
+    if (!order || typeof order !== 'object') {
+      throw new Error('Invalid order: must be an object');
+    }
+
+    const strategy = this.factory.getStrategy(order.type);
+    return strategy.process(order);
+  }
+}
+
+// ============================================
+// Usage Examples
+// ============================================
+
+// Create processor instance
+const processor = new OrderProcessor();
+
+// Process different order types
+const digitalOrder = processor.processOrder({
+  type: 'digital',
+  id: 'DIG-001',
+  items: ['software license']
+});
+
+const physicalOrder = processor.processOrder({
+  type: 'physical',
+  id: 'PHY-001',
+  items: ['laptop'],
+  shippingAddress: '123 Main St'
+});
+
+const subscriptionOrder = processor.processOrder({
+  type: 'subscription',
+  id: 'SUB-001',
+  items: ['monthly service'],
+  billingCycle: 'monthly'
+});
+
+// Processing unknown order type (falls back to DefaultOrderStrategy)
+const unknownOrder = processor.processOrder({
+  type: 'unknown',
+  id: 'UNK-001',
+  items: ['something']
+});
+
+console.log('Digital Order:', digitalOrder);   // { type: 'digital', status: 'delivered', ... }
+console.log('Physical Order:', physicalOrder);  // { type: 'physical', status: 'shipped', ... }
+console.log('Subscription Order:', subscriptionOrder); // { type: 'subscription', status: 'active', ... }
+console.log('Unknown Order:', unknownOrder);    // { type: 'unknown', status: 'pending', ... }
+
+// ============================================
+// Extensibility Example: Adding a New Order Type
+// ============================================
+
+// Define a new strategy for a new order type
+class ServiceOrderStrategy implements OrderProcessingStrategy {
+  process(order: Order): Order {
+    return { ...order, status: 'scheduled' };
+  }
+}
+
+// Register the new strategy with the factory
+const customFactory = new OrderProcessingStrategyFactory();
+customFactory.registerStrategy('service', new ServiceOrderStrategy());
+
+// Create processor with custom factory
+const customProcessor = new OrderProcessor(customFactory);
+
+// Now we can process service orders
+const serviceOrder = customProcessor.processOrder({
+  type: 'service',
+  id: 'SRV-001',
+  items: ['consultation']
+});
+
+console.log('Service Order:', serviceOrder);  // { type: 'service', status: 'scheduled', ... }
+
+// ============================================
+// Benefits of Strategy Pattern:
+// ============================================
+/*
+1. Open/Closed Principle: Easy to add new order types without modifying existing code
+2. Single Responsibility: Each strategy handles one specific order type
+3. Testability: Each strategy can be tested independently
+4. Flexibility: Strategies can be swapped at runtime
+5. Type Safety: TypeScript interfaces ensure contract compliance
+6. Immutability: Returns new objects instead of mutating input
+7. Extensibility: New strategies can be registered via factory
+8. Encapsulation: Each strategy hides its implementation details
+*/