@siftd/connect-agent 0.2.12 → 0.2.14

package/dist/agent.js

@@ -197,14 +197,14 @@ export async function runAgent(pollInterval = 2000) {
         },
     });
     // Graceful shutdown
-    process.on('SIGINT', () => {
+    process.on('SIGINT', async () => {
         console.log('\n[AGENT] Shutting down...');
         stopHeartbeat();
         if (wsClient) {
             wsClient.close();
         }
         if (orchestrator) {
-            orchestrator.shutdown();
+            await orchestrator.shutdown();
         }
         process.exit(0);
     });

package/dist/core/system-indexer.d.ts

@@ -7,12 +7,30 @@
  *
  * No MCP. No new protocols. Just smart memory use.
  */
-import { AdvancedMemoryStore } from './memory-advanced.js';
+interface MemoryStore {
+    remember(content: string, options?: {
+        type?: 'episodic' | 'semantic' | 'procedural' | 'working';
+        source?: string;
+        importance?: number;
+        tags?: string[];
+    }): Promise<string>;
+    search(query: string, options?: {
+        type?: 'episodic' | 'semantic' | 'procedural' | 'working';
+        limit?: number;
+        minImportance?: number;
+    }): Promise<{
+        id: string;
+        content: string;
+        importance: number;
+        tags?: string[];
+    }[]>;
+    forget?(id: string): Promise<boolean>;
+}
 export declare class SystemIndexer {
     private memory;
     private home;
     private indexed;
-    constructor(memory: AdvancedMemoryStore);
+    constructor(memory: MemoryStore);
     /**
      * Index the user's home directory structure into memory
      */
@@ -63,3 +81,4 @@ export declare class SystemIndexer {
         total: number;
     }>;
 }
+export {};

package/dist/core/system-indexer.js

@@ -345,7 +345,7 @@ export class SystemIndexer {
             type: 'semantic'
         });
         for (const mem of oldMemories) {
-            if (mem.tags.includes('filesystem')) {
+            if (mem.tags?.includes('filesystem') && this.memory.forget) {
                 await this.memory.forget(mem.id);
             }
         }

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.12'; // Should match package.json
+const VERSION = '0.2.14'; // Should match package.json
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.d.ts

@@ -11,7 +11,6 @@ export declare class MasterOrchestrator {
     private model;
     private maxTokens;
     private memory;
-    private postgresMemory;
     private scheduler;
     private indexer;
     private jobs;
@@ -20,13 +19,10 @@ export declare class MasterOrchestrator {
     private workspaceDir;
     private claudePath;
     private initialized;
-    private usingPostgres;
-    private voyageApiKey?;
     private bashTool;
     private webTools;
     private workerTools;
     private sharedState;
-    private fileWatcher;
     private verboseMode;
     constructor(options: {
         apiKey: string;
@@ -123,26 +119,6 @@ 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

@@ -11,7 +11,6 @@ import { AdvancedMemoryStore } from './core/memory-advanced.js';
 import { PostgresMemoryStore, isPostgresConfigured } from './core/memory-postgres.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';
@@ -76,7 +75,6 @@ export class MasterOrchestrator {
     model;
     maxTokens;
     memory;
-    postgresMemory = null;
     scheduler;
     indexer;
     jobs = new Map();
@@ -85,14 +83,11 @@ export class MasterOrchestrator {
     workspaceDir;
     claudePath;
     initialized = false;
-    usingPostgres = false;
-    voyageApiKey;
     // New tools from whatsapp-claude
     bashTool;
     webTools;
     workerTools;
     sharedState;
-    fileWatcher;
     verboseMode = new Map(); // per-user verbose mode
     constructor(options) {
         this.client = new Anthropic({ apiKey: options.apiKey });
@@ -100,33 +95,32 @@ export class MasterOrchestrator {
         this.maxTokens = options.maxTokens || 4096;
         this.userId = options.userId;
         this.workspaceDir = options.workspaceDir || process.env.HOME || '/tmp';
-        this.voyageApiKey = options.voyageApiKey;
         // Find claude binary - critical for worker delegation
         this.claudePath = this.findClaudeBinary();
         console.log(`[ORCHESTRATOR] Claude binary: ${this.claudePath}`);
-        // Memory initialization is deferred to initialize() for async Postgres support
-        // For now, create SQLite as fallback (will be replaced if Postgres is configured)
-        this.memory = new AdvancedMemoryStore({
-            dbPath: `memories_${options.userId}.db`,
-            vectorPath: `./memory_vectors_${options.userId}`,
-            voyageApiKey: options.voyageApiKey
-        });
+        // Initialize memory - use Postgres if DATABASE_URL is set, otherwise SQLite
+        if (isPostgresConfigured()) {
+            console.log('[ORCHESTRATOR] DATABASE_URL detected, using PostgreSQL + pgvector');
+            this.memory = new PostgresMemoryStore({
+                connectionString: process.env.DATABASE_URL,
+                userId: options.userId
+            });
+        }
+        else {
+            this.memory = new AdvancedMemoryStore({
+                dbPath: `memories_${options.userId}.db`,
+                vectorPath: `./memory_vectors_${options.userId}`,
+                voyageApiKey: options.voyageApiKey
+            });
+        }
         this.scheduler = new TaskScheduler(`scheduled_${options.userId}.json`);
-        // Create indexer (will be re-initialized after memory setup)
+        // Create indexer (will index on first initialize call)
         this.indexer = new SystemIndexer(this.memory);
         // Initialize new tools
         this.bashTool = new BashTool(this.workspaceDir);
         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
@@ -135,39 +129,14 @@ export class MasterOrchestrator {
         if (this.initialized)
             return;
         console.log('[ORCHESTRATOR] Initializing...');
-        // Check for Postgres and switch memory backend if configured
-        if (isPostgresConfigured()) {
-            try {
-                console.log('[ORCHESTRATOR] DATABASE_URL detected, using PostgreSQL + pgvector');
-                this.postgresMemory = new PostgresMemoryStore({
-                    connectionString: process.env.DATABASE_URL,
-                    userId: this.userId
-                });
-                await this.postgresMemory.initialize();
-                this.memory = this.postgresMemory;
-                this.usingPostgres = true;
-                // Re-create indexer with Postgres memory
-                // Note: SystemIndexer expects AdvancedMemoryStore, so we skip indexing for Postgres
-                console.log('[ORCHESTRATOR] Memory backend: PostgreSQL + pgvector');
-            }
-            catch (error) {
-                console.error('[ORCHESTRATOR] PostgreSQL initialization failed, falling back to SQLite:', error);
-                this.usingPostgres = false;
-            }
-        }
-        else {
-            console.log('[ORCHESTRATOR] Memory backend: SQLite + vectra (local)');
+        // Index the filesystem into memory
+        try {
+            const result = await this.indexer.indexHome();
+            console.log(`[ORCHESTRATOR] Filesystem indexed: ${result.projects} projects, ${result.directories} directories`);
         }
-        // Index the filesystem into memory (only for SQLite - Postgres typically runs in cloud)
-        if (!this.usingPostgres) {
-            try {
-                const result = await this.indexer.indexHome();
-                console.log(`[ORCHESTRATOR] Filesystem indexed: ${result.projects} projects, ${result.directories} directories`);
-            }
-            catch (error) {
-                console.error('[ORCHESTRATOR] Filesystem indexing failed:', error);
-                // Continue anyway - indexing is a nice-to-have
-            }
+        catch (error) {
+            console.error('[ORCHESTRATOR] Filesystem indexing failed:', error);
+            // Continue anyway - indexing is a nice-to-have
         }
         this.initialized = true;
     }
@@ -634,84 +603,6 @@ 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: []
-                }
             }
         ];
     }
@@ -791,22 +682,6 @@ 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}` };
             }
@@ -1203,99 +1078,6 @@ 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
      */
@@ -1339,16 +1121,6 @@ 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;
         }
@@ -1369,13 +1141,11 @@ This enables parallel workers to coordinate.`;
      * Shutdown cleanly
      */
     async shutdown() {
-        this.fileWatcher.stopAll();
         this.scheduler.shutdown();
-        // Close memory store (Postgres is async, SQLite is sync)
-        if (this.usingPostgres && this.postgresMemory) {
-            await this.postgresMemory.close();
+        if (this.memory instanceof PostgresMemoryStore) {
+            await this.memory.close();
         }
-        else if ('close' in this.memory) {
+        else {
             this.memory.close();
         }
     }

package/package.json

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