@siftd/connect-agent 0.2.9 → 0.2.10

package/dist/core/file-watcher.d.ts

@@ -0,0 +1,109 @@
+/**
+ * File Watcher for Reactive Workflows
+ *
+ * Enables the orchestrator to:
+ * - Watch directories/files for changes
+ * - Trigger callbacks on file events
+ * - Support glob patterns for filtering
+ * - Debounce rapid changes
+ */
+import { EventEmitter } from 'events';
+export type FileEventType = 'add' | 'change' | 'unlink' | 'addDir' | 'unlinkDir';
+export interface FileEvent {
+    type: FileEventType;
+    path: string;
+    timestamp: string;
+}
+export interface WatchRule {
+    id: string;
+    pattern: string;
+    events: FileEventType[];
+    action: string;
+    debounceMs?: number;
+    enabled: boolean;
+    lastTriggered?: string;
+}
+export interface WatcherConfig {
+    rulesFile: string;
+    defaultDebounce: number;
+}
+export declare class FileWatcher extends EventEmitter {
+    private watchers;
+    private rules;
+    private debounceTimers;
+    private config;
+    private rulesFile;
+    constructor(workspaceDir: string, config?: Partial<WatcherConfig>);
+    /**
+     * Add a watch rule
+     */
+    addRule(rule: Omit<WatchRule, 'id' | 'enabled'>): string;
+    /**
+     * Remove a watch rule
+     */
+    removeRule(id: string): boolean;
+    /**
+     * Enable/disable a rule
+     */
+    toggleRule(id: string, enabled: boolean): boolean;
+    /**
+     * List all rules
+     */
+    listRules(): WatchRule[];
+    /**
+     * Get a specific rule
+     */
+    getRule(id: string): WatchRule | undefined;
+    /**
+     * Watch a specific path
+     */
+    watch(targetPath: string, callback: (event: FileEvent) => void): string;
+    /**
+     * Stop watching a specific watcher
+     */
+    unwatch(watcherId: string): void;
+    /**
+     * Stop all watchers
+     */
+    stopAll(): void;
+    /**
+     * Get watcher status
+     */
+    status(): {
+        activeWatchers: number;
+        rules: number;
+        enabledRules: number;
+    };
+    private watchDirectory;
+    private watchFile;
+    private determineEventType;
+    private startWatching;
+    private stopWatching;
+    private loadRules;
+    private saveRules;
+}
+/**
+ * Common watch patterns for development workflows
+ */
+export declare const COMMON_PATTERNS: {
+    typescript: {
+        pattern: string;
+        events: FileEventType[];
+        action: string;
+    };
+    tests: {
+        pattern: string;
+        events: FileEventType[];
+        action: string;
+    };
+    config: {
+        pattern: string;
+        events: FileEventType[];
+        action: string;
+    };
+    markdown: {
+        pattern: string;
+        events: FileEventType[];
+        action: string;
+    };
+};

package/dist/core/file-watcher.js

@@ -0,0 +1,275 @@
+/**
+ * File Watcher for Reactive Workflows
+ *
+ * Enables the orchestrator to:
+ * - Watch directories/files for changes
+ * - Trigger callbacks on file events
+ * - Support glob patterns for filtering
+ * - Debounce rapid changes
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { EventEmitter } from 'events';
+export class FileWatcher extends EventEmitter {
+    watchers = new Map();
+    rules = new Map();
+    debounceTimers = new Map();
+    config;
+    rulesFile;
+    constructor(workspaceDir, config) {
+        super();
+        this.rulesFile = config?.rulesFile || path.join(workspaceDir, '.watch-rules.json');
+        this.config = {
+            rulesFile: this.rulesFile,
+            defaultDebounce: config?.defaultDebounce || 500
+        };
+        this.loadRules();
+    }
+    /**
+     * Add a watch rule
+     */
+    addRule(rule) {
+        const id = `watch_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+        const fullRule = {
+            ...rule,
+            id,
+            enabled: true,
+            debounceMs: rule.debounceMs || this.config.defaultDebounce
+        };
+        this.rules.set(id, fullRule);
+        this.saveRules();
+        this.startWatching(fullRule);
+        return id;
+    }
+    /**
+     * Remove a watch rule
+     */
+    removeRule(id) {
+        const rule = this.rules.get(id);
+        if (!rule)
+            return false;
+        this.stopWatching(rule);
+        this.rules.delete(id);
+        this.saveRules();
+        return true;
+    }
+    /**
+     * Enable/disable a rule
+     */
+    toggleRule(id, enabled) {
+        const rule = this.rules.get(id);
+        if (!rule)
+            return false;
+        rule.enabled = enabled;
+        if (enabled) {
+            this.startWatching(rule);
+        }
+        else {
+            this.stopWatching(rule);
+        }
+        this.saveRules();
+        return true;
+    }
+    /**
+     * List all rules
+     */
+    listRules() {
+        return Array.from(this.rules.values());
+    }
+    /**
+     * Get a specific rule
+     */
+    getRule(id) {
+        return this.rules.get(id);
+    }
+    /**
+     * Watch a specific path
+     */
+    watch(targetPath, callback) {
+        const id = `direct_${Date.now()}`;
+        try {
+            const resolvedPath = path.resolve(targetPath);
+            const stat = fs.statSync(resolvedPath);
+            if (stat.isDirectory()) {
+                this.watchDirectory(resolvedPath, callback, id);
+            }
+            else {
+                this.watchFile(resolvedPath, callback, id);
+            }
+            return id;
+        }
+        catch (error) {
+            console.error(`[WATCHER] Failed to watch ${targetPath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Stop watching a specific watcher
+     */
+    unwatch(watcherId) {
+        const watcher = this.watchers.get(watcherId);
+        if (watcher) {
+            watcher.close();
+            this.watchers.delete(watcherId);
+        }
+    }
+    /**
+     * Stop all watchers
+     */
+    stopAll() {
+        for (const [id, watcher] of this.watchers) {
+            watcher.close();
+        }
+        this.watchers.clear();
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+    }
+    /**
+     * Get watcher status
+     */
+    status() {
+        return {
+            activeWatchers: this.watchers.size,
+            rules: this.rules.size,
+            enabledRules: Array.from(this.rules.values()).filter(r => r.enabled).length
+        };
+    }
+    watchDirectory(dirPath, callback, id) {
+        const watcher = fs.watch(dirPath, { recursive: true }, (eventType, filename) => {
+            if (!filename)
+                return;
+            const fullPath = path.join(dirPath, filename);
+            const event = {
+                type: eventType === 'rename' ? this.determineEventType(fullPath) : 'change',
+                path: fullPath,
+                timestamp: new Date().toISOString()
+            };
+            callback(event);
+        });
+        this.watchers.set(id, watcher);
+    }
+    watchFile(filePath, callback, id) {
+        const watcher = fs.watch(filePath, (eventType) => {
+            const event = {
+                type: eventType === 'rename' ? 'unlink' : 'change',
+                path: filePath,
+                timestamp: new Date().toISOString()
+            };
+            callback(event);
+        });
+        this.watchers.set(id, watcher);
+    }
+    determineEventType(filePath) {
+        try {
+            const stat = fs.statSync(filePath);
+            return stat.isDirectory() ? 'addDir' : 'add';
+        }
+        catch {
+            return 'unlink';
+        }
+    }
+    startWatching(rule) {
+        if (!rule.enabled)
+            return;
+        try {
+            const targetPath = path.resolve(rule.pattern);
+            // Check if path exists
+            if (!fs.existsSync(targetPath)) {
+                console.log(`[WATCHER] Path does not exist yet: ${targetPath}`);
+                return;
+            }
+            const callback = (event) => {
+                if (!rule.events.includes(event.type))
+                    return;
+                // Debounce
+                const debounceKey = `${rule.id}_${event.path}`;
+                const existing = this.debounceTimers.get(debounceKey);
+                if (existing) {
+                    clearTimeout(existing);
+                }
+                const timer = setTimeout(() => {
+                    this.debounceTimers.delete(debounceKey);
+                    rule.lastTriggered = new Date().toISOString();
+                    this.saveRules();
+                    // Emit event for orchestrator to handle
+                    this.emit('trigger', {
+                        rule,
+                        event,
+                        action: rule.action
+                    });
+                }, rule.debounceMs || this.config.defaultDebounce);
+                this.debounceTimers.set(debounceKey, timer);
+            };
+            this.watch(targetPath, callback);
+            console.log(`[WATCHER] Started watching: ${rule.pattern}`);
+        }
+        catch (error) {
+            console.error(`[WATCHER] Failed to start watching ${rule.pattern}:`, error);
+        }
+    }
+    stopWatching(rule) {
+        // Find and close watchers for this rule
+        for (const [id, watcher] of this.watchers) {
+            if (id.includes(rule.id)) {
+                watcher.close();
+                this.watchers.delete(id);
+            }
+        }
+    }
+    loadRules() {
+        try {
+            if (fs.existsSync(this.rulesFile)) {
+                const data = JSON.parse(fs.readFileSync(this.rulesFile, 'utf8'));
+                for (const rule of data.rules || []) {
+                    this.rules.set(rule.id, rule);
+                    if (rule.enabled) {
+                        this.startWatching(rule);
+                    }
+                }
+                console.log(`[WATCHER] Loaded ${this.rules.size} watch rules`);
+            }
+        }
+        catch (error) {
+            console.error('[WATCHER] Failed to load rules:', error);
+        }
+    }
+    saveRules() {
+        try {
+            const data = {
+                rules: Array.from(this.rules.values()),
+                savedAt: new Date().toISOString()
+            };
+            fs.writeFileSync(this.rulesFile, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            console.error('[WATCHER] Failed to save rules:', error);
+        }
+    }
+}
+/**
+ * Common watch patterns for development workflows
+ */
+export const COMMON_PATTERNS = {
+    typescript: {
+        pattern: '**/*.ts',
+        events: ['change', 'add'],
+        action: 'TypeScript file changed - run type check and tests'
+    },
+    tests: {
+        pattern: '**/*.test.ts',
+        events: ['change', 'add'],
+        action: 'Test file changed - run tests'
+    },
+    config: {
+        pattern: '**/package.json',
+        events: ['change'],
+        action: 'Package.json changed - check for dependency updates'
+    },
+    markdown: {
+        pattern: '**/*.md',
+        events: ['change', 'add'],
+        action: 'Documentation changed - validate links and formatting'
+    }
+};

package/dist/heartbeat.js

@@ -10,7 +10,7 @@ import { hostname } from 'os';
 import { createHash } from 'crypto';
 import { getServerUrl, getAgentToken, getUserId, isCloudMode } from './config.js';
 const HEARTBEAT_INTERVAL = 10000; // 10 seconds
-const VERSION = '0.2.9'; // Should match package.json
+const VERSION = '0.2.10'; // Should match package.json
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.d.ts

@@ -23,6 +23,7 @@ export declare class MasterOrchestrator {
     private webTools;
     private workerTools;
     private sharedState;
+    private fileWatcher;
     private verboseMode;
     constructor(options: {
         apiKey: string;
@@ -119,6 +120,26 @@ export declare class MasterOrchestrator {
      * Stop a running server on a port
      */
     private executeStopServer;
+    /**
+     * Add a file watch rule
+     */
+    private executeAddWatchRule;
+    /**
+     * Remove a file watch rule
+     */
+    private executeRemoveWatchRule;
+    /**
+     * List all file watch rules
+     */
+    private executeListWatchRules;
+    /**
+     * Toggle a file watch rule
+     */
+    private executeToggleWatchRule;
+    /**
+     * Get file watcher status
+     */
+    private executeWatchStatus;
     /**
      * Format tool preview for user
      */

package/dist/orchestrator.js

@@ -10,6 +10,7 @@ import { existsSync } from 'fs';
 import { AdvancedMemoryStore } from './core/memory-advanced.js';
 import { TaskScheduler } from './core/scheduler.js';
 import { SystemIndexer } from './core/system-indexer.js';
+import { FileWatcher } from './core/file-watcher.js';
 import { BashTool } from './tools/bash.js';
 import { WebTools } from './tools/web.js';
 import { WorkerTools } from './tools/worker.js';
@@ -87,6 +88,7 @@ export class MasterOrchestrator {
     webTools;
     workerTools;
     sharedState;
+    fileWatcher;
     verboseMode = new Map(); // per-user verbose mode
     constructor(options) {
         this.client = new Anthropic({ apiKey: options.apiKey });
@@ -111,6 +113,14 @@ export class MasterOrchestrator {
         this.webTools = new WebTools();
         this.workerTools = new WorkerTools(this.workspaceDir);
         this.sharedState = new SharedState(this.workspaceDir);
+        this.fileWatcher = new FileWatcher(this.workspaceDir);
+        // Set up file watcher trigger handler
+        this.fileWatcher.on('trigger', async ({ rule, event, action }) => {
+            console.log(`[WATCHER] Triggered: ${rule.pattern} (${event.type}: ${event.path})`);
+            // Auto-delegate to worker when file changes
+            const task = `${action}\n\nTriggered by file change:\n- File: ${event.path}\n- Event: ${event.type}\n- Rule: ${rule.pattern}`;
+            this.delegateToWorker(task, undefined, this.workspaceDir);
+        });
     }
     /**
      * Initialize the orchestrator - indexes filesystem on first call
@@ -593,6 +603,84 @@ Be specific about what you want done.`,
                     },
                     required: ['port']
                 }
+            },
+            // File watching tools for reactive workflows
+            {
+                name: 'add_watch_rule',
+                description: 'Add a file watch rule to automatically trigger actions when files change. Useful for reactive workflows like auto-running tests when code changes.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        pattern: {
+                            type: 'string',
+                            description: 'File path or directory to watch (e.g., "./src", "/path/to/file.ts")'
+                        },
+                        events: {
+                            type: 'array',
+                            items: { type: 'string', enum: ['add', 'change', 'unlink', 'addDir', 'unlinkDir'] },
+                            description: 'Events to watch for (default: ["change", "add"])'
+                        },
+                        action: {
+                            type: 'string',
+                            description: 'Task description to execute when triggered (sent to a worker)'
+                        },
+                        debounce_ms: {
+                            type: 'number',
+                            description: 'Debounce delay in milliseconds (default: 500)'
+                        }
+                    },
+                    required: ['pattern', 'action']
+                }
+            },
+            {
+                name: 'remove_watch_rule',
+                description: 'Remove a file watch rule by its ID.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        rule_id: {
+                            type: 'string',
+                            description: 'The ID of the watch rule to remove'
+                        }
+                    },
+                    required: ['rule_id']
+                }
+            },
+            {
+                name: 'list_watch_rules',
+                description: 'List all active file watch rules.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
+            },
+            {
+                name: 'toggle_watch_rule',
+                description: 'Enable or disable a file watch rule.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        rule_id: {
+                            type: 'string',
+                            description: 'The ID of the watch rule to toggle'
+                        },
+                        enabled: {
+                            type: 'boolean',
+                            description: 'Whether to enable (true) or disable (false) the rule'
+                        }
+                    },
+                    required: ['rule_id', 'enabled']
+                }
+            },
+            {
+                name: 'watch_status',
+                description: 'Get the status of the file watcher system.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
             }
         ];
     }
@@ -672,6 +760,22 @@ Be specific about what you want done.`,
                 case 'stop_local_server':
                     result = await this.executeStopServer(input.port);
                     break;
+                // File watching tools
+                case 'add_watch_rule':
+                    result = await this.executeAddWatchRule(input.pattern, input.action, input.events, input.debounce_ms);
+                    break;
+                case 'remove_watch_rule':
+                    result = await this.executeRemoveWatchRule(input.rule_id);
+                    break;
+                case 'list_watch_rules':
+                    result = await this.executeListWatchRules();
+                    break;
+                case 'toggle_watch_rule':
+                    result = await this.executeToggleWatchRule(input.rule_id, input.enabled);
+                    break;
+                case 'watch_status':
+                    result = await this.executeWatchStatus();
+                    break;
                 default:
                     result = { success: false, output: `Unknown tool: ${toolUse.name}` };
             }
@@ -1068,6 +1172,99 @@ This enables parallel workers to coordinate.`;
             return { success: false, output: `No server running on port ${port}` };
         }
     }
+    /**
+     * Add a file watch rule
+     */
+    async executeAddWatchRule(pattern, action, events, debounceMs) {
+        try {
+            const validEvents = ['add', 'change', 'unlink', 'addDir', 'unlinkDir'];
+            const eventList = events
+                ? events.filter((e) => validEvents.includes(e))
+                : ['change', 'add'];
+            const ruleId = this.fileWatcher.addRule({
+                pattern,
+                events: eventList,
+                action,
+                debounceMs
+            });
+            console.log(`[ORCHESTRATOR] Added watch rule ${ruleId}: ${pattern}`);
+            return {
+                success: true,
+                output: `Watch rule added:\n- ID: ${ruleId}\n- Pattern: ${pattern}\n- Events: ${eventList.join(', ')}\n- Action: ${action}\n- Debounce: ${debounceMs || 500}ms`
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to add watch rule: ${msg}` };
+        }
+    }
+    /**
+     * Remove a file watch rule
+     */
+    async executeRemoveWatchRule(ruleId) {
+        try {
+            const removed = this.fileWatcher.removeRule(ruleId);
+            if (removed) {
+                console.log(`[ORCHESTRATOR] Removed watch rule ${ruleId}`);
+                return { success: true, output: `Watch rule ${ruleId} removed` };
+            }
+            return { success: false, output: `Watch rule ${ruleId} not found` };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to remove watch rule: ${msg}` };
+        }
+    }
+    /**
+     * List all file watch rules
+     */
+    async executeListWatchRules() {
+        try {
+            const rules = this.fileWatcher.listRules();
+            if (rules.length === 0) {
+                return { success: true, output: 'No watch rules configured.' };
+            }
+            const output = rules.map(r => `${r.enabled ? '✓' : '⏸'} ${r.id}\n  Pattern: ${r.pattern}\n  Events: ${r.events.join(', ')}\n  Action: ${r.action.slice(0, 60)}...${r.lastTriggered ? `\n  Last triggered: ${r.lastTriggered}` : ''}`).join('\n\n');
+            return { success: true, output: `Watch Rules (${rules.length}):\n\n${output}` };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to list watch rules: ${msg}` };
+        }
+    }
+    /**
+     * Toggle a file watch rule
+     */
+    async executeToggleWatchRule(ruleId, enabled) {
+        try {
+            const toggled = this.fileWatcher.toggleRule(ruleId, enabled);
+            if (toggled) {
+                console.log(`[ORCHESTRATOR] ${enabled ? 'Enabled' : 'Disabled'} watch rule ${ruleId}`);
+                return { success: true, output: `Watch rule ${ruleId} ${enabled ? 'enabled' : 'disabled'}` };
+            }
+            return { success: false, output: `Watch rule ${ruleId} not found` };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to toggle watch rule: ${msg}` };
+        }
+    }
+    /**
+     * Get file watcher status
+     */
+    async executeWatchStatus() {
+        try {
+            const status = this.fileWatcher.status();
+            return {
+                success: true,
+                output: `File Watcher Status:\n- Active watchers: ${status.activeWatchers}\n- Total rules: ${status.rules}\n- Enabled rules: ${status.enabledRules}`
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to get watcher status: ${msg}` };
+        }
+    }
     /**
      * Format tool preview for user
      */
@@ -1111,6 +1308,16 @@ This enables parallel workers to coordinate.`;
                 return `Starting server on port ${input.port || 8080}...`;
             case 'stop_local_server':
                 return `Stopping server on port ${input.port}...`;
+            case 'add_watch_rule':
+                return `Adding watch rule for ${input.pattern}...`;
+            case 'remove_watch_rule':
+                return `Removing watch rule ${input.rule_id}...`;
+            case 'list_watch_rules':
+                return 'Listing watch rules...';
+            case 'toggle_watch_rule':
+                return `${input.enabled ? 'Enabling' : 'Disabling'} watch rule ${input.rule_id}...`;
+            case 'watch_status':
+                return 'Getting watcher status...';
             default:
                 return null;
         }
@@ -1131,6 +1338,7 @@ This enables parallel workers to coordinate.`;
      * Shutdown cleanly
      */
     shutdown() {
+        this.fileWatcher.stopAll();
         this.scheduler.shutdown();
         this.memory.close();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siftd/connect-agent",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",