agents-library 1.1.0

package/dist/shadow-agent-factory.d.ts

@@ -0,0 +1,623 @@
+/**
+ * Shadow Agent Factory
+ * =====================
+ *
+ * Factory for creating shadow agents (backup/monitoring agents) with
+ * configuration-driven instantiation and shared infrastructure.
+ *
+ * Architecture Pattern: **Composition over Inheritance**
+ * - BaseShadowAgent COMPOSES with BaseBot (does NOT extend)
+ * - Uses delegation pattern to access BaseBot's circuit breaker and retry logic
+ * - This avoids tight coupling and allows flexible behavior customization
+ *
+ * Design Principles:
+ * - Factory pattern for consistent agent creation
+ * - Composition over inheritance for flexibility
+ * - Template method pattern for lifecycle management (start/stop)
+ * - Observer pattern for filesystem and git ref watching
+ *
+ * Shadow Agent Responsibilities:
+ * - Monitor worker agent worktrees for file changes
+ * - Create granular backup commits in shadow worktrees
+ * - Mirror worker commits to shadow branch
+ * - Publish backup events to KĀDI broker
+ *
+ * @module shadow-agent-factory
+ */
+import { KadiClient, z } from '@kadi.build/core';
+import type { ShadowAgentConfig } from './types/agent-config.js';
+import { BaseAgent } from './base-agent.js';
+/**
+ * Base class for shadow agents (backup/monitoring agents)
+ *
+ * **CIRCUIT BREAKER PATTERN**: This class implements its own circuit breaker for git operations.
+ * - Tracks consecutive failures and opens circuit after threshold
+ * - Prevents cascading failures from overwhelming the system
+ * - Auto-resets circuit after timeout period
+ * - Provides resilient git operations with retry logic
+ *
+ * Why Not Use BaseBot?
+ * - BaseBot is designed for chat bots and requires Anthropic API key
+ * - Shadow agents don't need Claude integration, just git operations
+ * - Simpler, focused circuit breaker implementation for git-specific needs
+ *
+ * Shadow Agent Architecture:
+ * 1. **Filesystem Watcher**: Monitors worker worktree for file operations (create/modify/delete)
+ * 2. **Git Ref Watcher**: Monitors worker commits to mirror them in shadow worktree
+ * 3. **Atomic Git Operations**: add + commit for each monitored event
+ * 4. **Circuit Breaker**: Error handling with retry and fallback via BaseBot
+ * 5. **Event Publishing**: Publishes backup completion/failure events
+ *
+ * Lifecycle:
+ * 1. Constructor: Initialize configuration and compose utilities
+ * 2. start(): Connect to broker, initialize watchers, subscribe to events
+ * 3. [Monitoring happens asynchronously via filesystem/git watchers]
+ * 4. stop(): Cleanup watchers, unsubscribe, disconnect from broker
+ *
+ * @example
+ * ```typescript
+ * const config: ShadowAgentConfig = {
+ *   role: 'artist',
+ *   workerWorktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+ *   shadowWorktreePath: 'C:/p4/Personal/SD/shadow-agent-playground-artist',
+ *   workerBranch: 'agent-artist',
+ *   shadowBranch: 'shadow-agent-artist',
+ *   brokerUrl: 'ws://localhost:8080/kadi',
+ *   networks: ['kadi'],
+ *   debounceMs: 1000
+ * };
+ *
+ * const agent = new BaseShadowAgent(config);
+ * await agent.start();
+ * // Agent now monitors worker worktree and creates shadow backups
+ * ```
+ */
+export declare class BaseShadowAgent {
+    /**
+     * KĀDI client for broker communication
+     *
+     * Used for:
+     * - Subscribing to events
+     * - Publishing backup completion/failure events
+     * - Accessing broker protocol for tool invocation
+     */
+    protected client: KadiClient;
+    /**
+     * Agent role (matches corresponding worker agent)
+     *
+     * Used for:
+     * - Event payload agent identification (shadow-agent-{role})
+     * - Logging and identification
+     */
+    protected role: string;
+    /**
+     * Absolute path to worker agent's git worktree
+     *
+     * Shadow agent watches this directory for file changes.
+     * This is the source of truth for file operations.
+     *
+     * @example 'C:/p4/Personal/SD/agent-playground-artist'
+     */
+    protected workerWorktreePath: string;
+    /**
+     * Absolute path to shadow agent's git worktree
+     *
+     * Shadow agent creates mirror commits in this directory.
+     * Must be a separate git repository from worker worktree.
+     *
+     * @example 'C:/p4/Personal/SD/shadow-agent-playground-artist'
+     */
+    protected shadowWorktreePath: string;
+    /**
+     * Git branch name in worker worktree to monitor
+     *
+     * Shadow agent watches for commits on this branch.
+     *
+     * @example 'agent-artist'
+     */
+    protected workerBranch: string;
+    /**
+     * Git branch name in shadow worktree for mirror commits
+     *
+     * Shadow agent creates commits on this branch.
+     *
+     * @example 'shadow-agent-artist'
+     */
+    protected shadowBranch: string;
+    /**
+     * Debounce delay in milliseconds for file change events
+     *
+     * Prevents creating multiple commits for rapid file changes.
+     * Shadow agent waits this duration after last change before creating commit.
+     *
+     * @default 1000
+     */
+    protected debounceMs: number;
+    /**
+     * Circuit breaker state for git operations
+     *
+     * Tracks consecutive failures and blocks operations when threshold exceeded.
+     * Prevents cascading failures and allows system to recover.
+     */
+    private gitCircuitOpen;
+    /**
+     * Consecutive git operation failure count
+     *
+     * Incremented on each failure, reset to 0 on success.
+     * Circuit opens when count reaches MAX_GIT_FAILURES threshold.
+     */
+    private gitFailureCount;
+    /**
+     * Maximum git failures before circuit opens
+     *
+     * @default 5
+     */
+    private readonly MAX_GIT_FAILURES;
+    /**
+     * Circuit breaker reset timeout in milliseconds
+     *
+     * After this duration, circuit automatically closes and retries are allowed.
+     *
+     * @default 60000 (1 minute)
+     */
+    private readonly CIRCUIT_RESET_TIME;
+    /**
+     * Full agent configuration
+     *
+     * Stored for reference and potential reconfiguration.
+     * Currently unused but reserved for future features (e.g., hot-reloading config).
+     */
+    private readonly config;
+    /**
+     * Whether this agent delegates connection management to a BaseAgent instance.
+     * When true, start() skips broker connection and stop() skips disconnection.
+     */
+    private readonly usesBaseAgent;
+    /**
+     * Filesystem watcher instance for monitoring worker worktree
+     *
+     * Monitors file operations (create, modify, delete) in worker worktree.
+     * Null until start() is called.
+     */
+    private fsWatcher;
+    /**
+     * Git ref watcher instance for monitoring worker branch commits
+     *
+     * Watches .git/refs/heads/{workerBranch} file for commit SHA changes.
+     * Uses fs.watch (not chokidar) for lightweight ref monitoring.
+     * Null until start() is called.
+     */
+    private refWatcher;
+    /**
+     * Previous commit SHA from worker branch
+     *
+     * Stores last known commit SHA to detect actual commit changes.
+     * Used to differentiate real commits from other ref updates.
+     * Null until first commit is detected.
+     */
+    private previousCommitSha;
+    /**
+     * Set of changed file paths awaiting backup processing
+     *
+     * Stores relative file paths from worker worktree for batch processing.
+     * Debounced to avoid rapid-fire commits for the same file.
+     *
+     * Key: Absolute file path
+     * Value: Debounce timeout handle
+     */
+    private debounceMap;
+    /**
+     * Debounce timeout for git ref watcher
+     *
+     * Stores timeout handle for debouncing ref change events.
+     * Prevents processing rapid ref updates.
+     */
+    private refDebounceTimeout;
+    /**
+     * Create a new BaseShadowAgent instance
+     *
+     * Initializes all configuration properties and composes utility classes
+     * (BaseBot, KadiEventPublisher). Does NOT connect to broker or start watchers yet -
+     * call start() to begin monitoring.
+     *
+     * @param config - Shadow agent configuration with all required fields
+     *
+     * @example
+     * ```typescript
+     * const agent = new BaseShadowAgent({
+     *   role: 'artist',
+     *   workerWorktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+     *   shadowWorktreePath: 'C:/p4/Personal/SD/shadow-agent-playground-artist',
+     *   workerBranch: 'agent-artist',
+     *   shadowBranch: 'shadow-agent-artist',
+     *   brokerUrl: 'ws://localhost:8080/kadi',
+     *   networks: ['kadi'],
+     *   debounceMs: 1000
+     * });
+     * ```
+     */
+    constructor(config: ShadowAgentConfig, baseAgent?: BaseAgent);
+    /**
+     * Start the shadow agent
+     *
+     * Performs initialization sequence:
+     * 1. Connect to KĀDI broker
+     * 2. Initialize broker protocol
+     * 3. Connect event publisher
+     * 4. Setup filesystem watcher for worker worktree
+     * 5. Setup git ref watcher for worker branch
+     * 6. Enter monitoring loop (non-blocking)
+     *
+     * After start() completes, the agent is ready to monitor file changes and create backups.
+     *
+     * @throws {Error} If broker connection fails after all retries
+     *
+     * @example
+     * ```typescript
+     * const agent = new BaseShadowAgent(config);
+     * await agent.start();
+     * console.log('Shadow agent is now monitoring worker worktree');
+     * ```
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the shadow agent
+     *
+     * Performs cleanup sequence:
+     * 1. Stop filesystem watcher
+     * 2. Stop git ref watcher
+     * 3. Clear debounce timers
+     * 4. Disconnect event publisher
+     * 5. Disconnect KĀDI client
+     * 6. Clear protocol reference
+     *
+     * After stop() completes, the agent is fully shut down and can be safely destroyed.
+     *
+     * @example
+     * ```typescript
+     * await agent.stop();
+     * console.log('Shadow agent has been stopped');
+     * ```
+     */
+    stop(): Promise<void>;
+    /**
+     * Setup filesystem watcher for worker worktree
+     *
+     * Monitors worker worktree for file operations (create, modify, delete) using chokidar.
+     * File changes are debounced and stored for batch backup processing.
+     *
+     * Configuration:
+     * - Watches: config.workerWorktreePath
+     * - Excludes: .git directory, node_modules, .env files
+     * - Debounce: config.debounceMs (default: 1000ms)
+     * - Stability threshold: Waits for file writes to complete
+     *
+     * Event Handling:
+     * - 'add': File created in worktree
+     * - 'change': Existing file modified
+     * - 'unlink': File deleted from worktree
+     * - 'error': Watcher errors (logged but non-fatal)
+     * - 'ready': Watcher initialization complete
+     *
+     * Debouncing Strategy:
+     * - Stores timeout handle in debounceMap for each file
+     * - Clears previous timeout if file changes again before debounce completes
+     * - Only processes file after debounceMs of inactivity
+     * - Prevents rapid-fire commits for the same file
+     *
+     * @throws {Error} If watcher initialization fails
+     *
+     * @example
+     * ```typescript
+     * await this.setupFilesystemWatcher();
+     * // Watcher is now monitoring worker worktree for file changes
+     * ```
+     */
+    protected setupFilesystemWatcher(): Promise<void>;
+    /**
+     * Setup git ref watcher for worker branch commits
+     *
+     * Monitors worker branch ref file (.git/refs/heads/{workerBranch}) for commit SHA changes
+     * using fs.watch. Detects new commits and triggers createShadowBackup after debounce period.
+     *
+     * Architecture:
+     * - Uses fs.watch (not chokidar) for lightweight ref monitoring
+     * - Reads commit SHA from ref file on each change
+     * - Compares with previousCommitSha to detect actual commits
+     * - Debounces to handle rapid ref updates (e.g., during rebase)
+     * - Triggers backup only for real commit changes
+     *
+     * Ref File Location:
+     * - {workerWorktreePath}/.git/refs/heads/{workerBranch}
+     * - Contains commit SHA as plain text (40 hex characters)
+     * - Updated by git on each commit to branch
+     *
+     * Change Detection Strategy:
+     * 1. fs.watch fires on any ref file modification
+     * 2. Read current SHA from ref file
+     * 3. Compare with previousCommitSha
+     * 4. If different, debounce and trigger backup
+     * 5. Update previousCommitSha for next comparison
+     *
+     * Debouncing:
+     * - Uses config.debounceMs delay (default: 1000ms)
+     * - Clears previous timeout if ref changes again
+     * - Prevents multiple backups during rapid commits
+     *
+     * @throws {Error} If ref file doesn't exist or can't be watched
+     *
+     * @example
+     * ```typescript
+     * await this.setupGitRefWatcher();
+     * // Watcher is now monitoring worker branch for commits
+     * ```
+     */
+    protected setupGitRefWatcher(): Promise<void>;
+    /**
+     * Create shadow backup commit
+     *
+     * Creates a mirror commit in shadow worktree by:
+     * 1. Parsing latest commit from worker worktree (git log)
+     * 2. Getting list of changed files (git diff)
+     * 3. Copying changed files from worker to shadow worktree
+     * 4. Creating mirror commit with format: Shadow: {operation} {fileName}
+     *
+     * Uses circuit breaker pattern to prevent cascading failures on git errors.
+     * Publishes backup completion/failure events to KĀDI broker.
+     *
+     * @param operation - Type of operation (e.g., 'Created', 'Modified', 'Deleted', 'COMMIT')
+     * @param fileName - File name or commit description
+     *
+     * @example
+     * ```typescript
+     * await this.createShadowBackup('Created', 'artwork.png');
+     * await this.createShadowBackup('COMMIT', 'Commit abc1234');
+     * ```
+     */
+    protected createShadowBackup(operation: string, fileName: string): Promise<void>;
+    /**
+     * Publish backup status event to KĀDI broker
+     *
+     * Publishes standardized BackupEvent with schema compliance for both success
+     * and failure scenarios. Events follow generic topic pattern: backup.{completed|failed} with agent identity in payload.
+     *
+     * Uses KadiEventPublisher for resilient event publishing with connection retry logic.
+     * Handles publishing failures gracefully without throwing errors.
+     *
+     * @param success - True for backup success, false for failure
+     * @param filesBackedUp - Array of file paths that were backed up
+     * @param operation - Backup operation type (e.g., 'mirror-commit', 'file-create')
+     * @param error - Error object if backup failed (optional)
+     *
+     * @example
+     * ```typescript
+     * // Success case
+     * await this.publishBackupStatus(true, ['artwork.png', 'logo.svg'], 'mirror-commit');
+     *
+     * // Failure case
+     * await this.publishBackupStatus(false, [], 'mirror-commit', new Error('Git operation failed'));
+     * ```
+     */
+    protected publishBackupStatus(success: boolean, filesBackedUp: string[], operation: string, error?: Error): Promise<void>;
+    /**
+     * Check circuit breaker state for git operations
+     *
+     * Returns true if circuit is open (blocking requests).
+     * Circuit opens after MAX_GIT_FAILURES consecutive failures and auto-resets after CIRCUIT_RESET_TIME.
+     *
+     * @returns True if circuit is open, false if closed
+     *
+     * @example
+     * ```typescript
+     * if (this.checkCircuitBreaker()) {
+     *   console.log('Circuit open - skipping backup operation');
+     *   return;
+     * }
+     * ```
+     */
+    protected checkCircuitBreaker(): boolean;
+    /**
+     * Record git operation failure and potentially open circuit breaker
+     *
+     * Increments failure count and opens circuit if threshold exceeded.
+     * Auto-resets circuit after timeout period.
+     *
+     * @param operation - Operation name for logging
+     * @param error - Error that occurred
+     */
+    protected recordGitFailure(operation: string, error: Error): void;
+    /**
+     * Record git operation success and reset failure count
+     *
+     * Resets failure counter on successful operation.
+     */
+    protected recordGitSuccess(): void;
+}
+/**
+ * Zod schema for ShadowAgentConfig validation
+ *
+ * Validates all required configuration fields for shadow agent instantiation.
+ * Ensures type safety and provides descriptive error messages for invalid configurations.
+ *
+ * Required Fields:
+ * - role: Agent role type (non-empty string)
+ * - workerWorktreePath: Absolute path to worker agent's git worktree (non-empty string)
+ * - shadowWorktreePath: Absolute path to shadow agent's git worktree (non-empty string)
+ * - workerBranch: Git branch name in worker worktree (non-empty string)
+ * - shadowBranch: Git branch name in shadow worktree (non-empty string)
+ * - brokerUrl: KĀDI broker WebSocket URL (non-empty string)
+ * - networks: Array of network names (at least one network required)
+ *
+ * Optional Fields:
+ * - debounceMs: Debounce delay in milliseconds (positive number, default: 1000)
+ *
+ * @example
+ * ```typescript
+ * const validConfig = {
+ *   role: 'artist',
+ *   workerWorktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+ *   shadowWorktreePath: 'C:/p4/Personal/SD/shadow-artist-backup',
+ *   workerBranch: 'main',
+ *   shadowBranch: 'shadow-main',
+ *   brokerUrl: 'ws://localhost:8080/kadi',
+ *   networks: ['kadi'],
+ *   debounceMs: 2000 // optional
+ * };
+ *
+ * ShadowAgentConfigSchema.parse(validConfig); // ✅ Passes validation
+ * ```
+ */
+export declare const ShadowAgentConfigSchema: z.ZodObject<{
+    role: z.ZodString;
+    workerWorktreePath: z.ZodString;
+    shadowWorktreePath: z.ZodString;
+    workerBranch: z.ZodString;
+    shadowBranch: z.ZodString;
+    brokerUrl: z.ZodString;
+    networks: z.ZodArray<z.ZodString>;
+    debounceMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Factory class for creating shadow agents
+ *
+ * Provides a clean API for shadow agent instantiation with validated configuration.
+ * Follows the same factory pattern as WorkerAgentFactory for consistency.
+ *
+ * The factory performs Zod schema validation on configuration before creating agents,
+ * ensuring type safety and providing descriptive error messages for invalid configurations.
+ *
+ * Usage Pattern:
+ * 1. Call ShadowAgentFactory.createAgent(config) with your configuration
+ * 2. If validation passes, receive a configured BaseShadowAgent instance
+ * 3. Call agent.start() to begin monitoring and backup operations
+ * 4. Call agent.stop() when done to cleanup resources
+ *
+ * @example Minimal Configuration
+ * ```typescript
+ * const agent = ShadowAgentFactory.createAgent({
+ *   role: 'artist',
+ *   workerWorktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+ *   shadowWorktreePath: 'C:/p4/Personal/SD/shadow-artist-backup',
+ *   workerBranch: 'main',
+ *   shadowBranch: 'shadow-main',
+ *   brokerUrl: 'ws://localhost:8080/kadi',
+ *   networks: ['kadi']
+ * });
+ *
+ * await agent.start();
+ * console.log('Shadow agent is now monitoring worker worktree');
+ * ```
+ *
+ * @example With Optional Debounce Configuration
+ * ```typescript
+ * const agent = ShadowAgentFactory.createAgent({
+ *   role: 'designer',
+ *   workerWorktreePath: 'C:/p4/Personal/SD/agent-playground-designer',
+ *   shadowWorktreePath: 'C:/p4/Personal/SD/shadow-designer-backup',
+ *   workerBranch: 'develop',
+ *   shadowBranch: 'shadow-develop',
+ *   brokerUrl: 'ws://localhost:8080/kadi',
+ *   networks: ['kadi', 'production'],
+ *   debounceMs: 2000 // Wait 2 seconds after last change
+ * });
+ *
+ * await agent.start();
+ * // Agent monitors for 2 seconds after each change before creating backup
+ * ```
+ *
+ * @example Error Handling with Validation
+ * ```typescript
+ * try {
+ *   const agent = ShadowAgentFactory.createAgent({
+ *     role: '', // ❌ Empty role will fail validation
+ *     workerWorktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+ *     shadowWorktreePath: 'C:/p4/Personal/SD/shadow-artist-backup',
+ *     workerBranch: 'main',
+ *     shadowBranch: 'shadow-main',
+ *     brokerUrl: 'ws://localhost:8080/kadi',
+ *     networks: []  // ❌ Empty networks array will fail validation
+ *   });
+ * } catch (error) {
+ *   console.error('Configuration validation failed:', error.message);
+ *   // Output: "Role is required and cannot be empty"
+ * }
+ * ```
+ */
+export declare class ShadowAgentFactory {
+    /**
+     * Create a shadow agent with validated configuration
+     *
+     * Static factory method for instantiating shadow agents with Zod schema validation.
+     * Validates all required configuration fields and provides descriptive error messages
+     * for invalid configurations.
+     *
+     * The method performs the following steps:
+     * 1. Validates configuration using ShadowAgentConfigSchema
+     * 2. If validation passes, creates BaseShadowAgent instance
+     * 3. Returns fully configured agent ready for start()
+     *
+     * Note: This method does NOT automatically start the agent. Caller must explicitly
+     * call agent.start() to begin monitoring and backup operations.
+     *
+     * @param config - Shadow agent configuration to validate and use
+     * @returns Configured BaseShadowAgent instance ready for start()
+     * @throws {ZodError} If configuration validation fails with detailed error messages
+     *
+     * @example Minimal Configuration
+     * ```typescript
+     * const agent = ShadowAgentFactory.createAgent({
+     *   role: 'artist',
+     *   workerWorktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+     *   shadowWorktreePath: 'C:/p4/Personal/SD/shadow-artist-backup',
+     *   workerBranch: 'main',
+     *   shadowBranch: 'shadow-main',
+     *   brokerUrl: 'ws://localhost:8080/kadi',
+     *   networks: ['kadi']
+     * });
+     *
+     * await agent.start();
+     * ```
+     *
+     * @example With Optional Configuration
+     * ```typescript
+     * const agent = ShadowAgentFactory.createAgent({
+     *   role: 'programmer',
+     *   workerWorktreePath: 'C:/p4/Personal/SD/agent-playground-programmer',
+     *   shadowWorktreePath: 'C:/p4/Personal/SD/shadow-programmer-backup',
+     *   workerBranch: 'feature/new-api',
+     *   shadowBranch: 'shadow-feature',
+     *   brokerUrl: 'ws://localhost:8080/kadi',
+     *   networks: ['kadi', 'staging'],
+     *   debounceMs: 3000 // Custom debounce delay
+     * });
+     *
+     * await agent.start();
+     * ```
+     */
+    static createAgent(config: ShadowAgentConfig, baseAgent?: BaseAgent): BaseShadowAgent;
+}
+/**
+ * Create a shadow agent with configuration
+ *
+ * Convenience function for instantiating shadow agents.
+ * Delegates to ShadowAgentFactory.createAgent().
+ *
+ * @param config - Shadow agent configuration
+ * @returns Configured BaseShadowAgent instance
+ *
+ * @example
+ * ```typescript
+ * const agent = createShadowAgent({
+ *   role: 'artist',
+ *   workerWorktreePath: 'C:/p4/Personal/SD/agent-playground-artist',
+ *   shadowWorktreePath: 'C:/p4/Personal/SD/shadow-agent-playground-artist',
+ *   workerBranch: 'agent-artist',
+ *   shadowBranch: 'shadow-agent-artist',
+ *   brokerUrl: 'ws://localhost:8080/kadi',
+ *   networks: ['kadi']
+ * });
+ * await agent.start();
+ * ```
+ */
+export declare function createShadowAgent(config: ShadowAgentConfig, baseAgent?: BaseAgent): BaseShadowAgent;
+//# sourceMappingURL=shadow-agent-factory.d.ts.map

package/dist/shadow-agent-factory.d.ts.map

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