@siftd/connect-agent 0.2.9 → 0.2.11

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/core/memory-interface.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Memory Store Interface
+ *
+ * Common interface for memory backends (SQLite, Postgres, etc.)
+ */
+export type MemoryType = 'episodic' | 'semantic' | 'procedural' | 'working';
+export interface Memory {
+    id: string;
+    type: MemoryType;
+    content: string;
+    summary?: string;
+    source: string;
+    timestamp: string;
+    lastAccessed: string;
+    importance: number;
+    accessCount: number;
+    decayRate: number;
+    associations: string[];
+    tags: string[];
+    hasEmbedding: boolean;
+}
+export interface MemorySearchOptions {
+    type?: MemoryType;
+    limit?: number;
+    minImportance?: number;
+}
+export interface MemoryStore {
+    /**
+     * Store a new memory
+     */
+    remember(content: string, options?: {
+        type?: MemoryType;
+        source?: string;
+        importance?: number;
+        tags?: string[];
+    }): Promise<string>;
+    /**
+     * Search memories using semantic similarity
+     */
+    search(query: string, options?: MemorySearchOptions): Promise<Memory[]>;
+    /**
+     * Get a specific memory by ID
+     */
+    get(id: string): Promise<Memory | null>;
+    /**
+     * Delete a memory
+     */
+    forget(id: string): Promise<boolean>;
+    /**
+     * Boost importance of a memory
+     */
+    reinforce(id: string, boost?: number): Promise<void>;
+    /**
+     * Get memory statistics
+     */
+    stats(): {
+        total: number;
+        byType: Record<string, number>;
+        avgImportance: number;
+        totalAssociations: number;
+    };
+    /**
+     * Close the store and release resources
+     */
+    close(): void | Promise<void>;
+}

package/dist/core/memory-interface.js

@@ -0,0 +1,6 @@
+/**
+ * Memory Store Interface
+ *
+ * Common interface for memory backends (SQLite, Postgres, etc.)
+ */
+export {};

package/dist/core/memory-postgres.d.ts

@@ -0,0 +1,109 @@
+/**
+ * PostgreSQL Memory Store with pgvector
+ *
+ * Cloud-native memory backend for Railway deployments.
+ * Uses pgvector extension for efficient vector similarity search.
+ *
+ * Features:
+ * - All AdvancedMemoryStore features
+ * - Scalable Postgres backend
+ * - pgvector for vector similarity
+ * - Shared across multiple agent instances
+ */
+export type MemoryType = 'episodic' | 'semantic' | 'procedural' | 'working';
+export interface Memory {
+    id: string;
+    type: MemoryType;
+    content: string;
+    summary?: string;
+    source: string;
+    timestamp: string;
+    lastAccessed: string;
+    importance: number;
+    accessCount: number;
+    decayRate: number;
+    associations: string[];
+    tags: string[];
+    hasEmbedding: boolean;
+}
+interface PostgresMemoryConfig {
+    connectionString: string;
+    userId?: string;
+    dimensions?: number;
+}
+export declare class PostgresMemoryStore {
+    private pool;
+    private userId;
+    private dimensions;
+    private initialized;
+    constructor(config: PostgresMemoryConfig);
+    /**
+     * Initialize database schema
+     */
+    initialize(): Promise<void>;
+    /**
+     * Store a memory
+     */
+    remember(content: string, options?: {
+        type?: MemoryType;
+        source?: string;
+        importance?: number;
+        tags?: string[];
+    }): Promise<string>;
+    /**
+     * Search memories using vector similarity
+     */
+    search(query: string, options?: {
+        type?: MemoryType;
+        limit?: number;
+        minImportance?: number;
+    }): Promise<Memory[]>;
+    /**
+     * Get memory by ID
+     */
+    get(id: string): Promise<Memory | null>;
+    /**
+     * Delete a memory
+     */
+    forget(id: string): Promise<boolean>;
+    /**
+     * Update memory importance
+     */
+    reinforce(id: string, boost?: number): Promise<void>;
+    /**
+     * Get memory statistics
+     */
+    stats(): {
+        total: number;
+        byType: Record<string, number>;
+        avgImportance: number;
+        totalAssociations: number;
+    };
+    private _cachedStats;
+    /**
+     * Update stats cache (call periodically)
+     */
+    updateStatsCache(): Promise<void>;
+    /**
+     * Apply temporal decay to all memories
+     */
+    applyDecay(): Promise<void>;
+    /**
+     * Cleanup old low-importance memories
+     */
+    cleanup(options?: {
+        maxAge?: number;
+        minImportance?: number;
+    }): Promise<number>;
+    /**
+     * Close the connection pool
+     */
+    close(): Promise<void>;
+    private inferType;
+    private calculateImportance;
+}
+/**
+ * Check if Postgres is available and configured
+ */
+export declare function isPostgresConfigured(): boolean;
+export {};

package/dist/core/memory-postgres.js

@@ -0,0 +1,374 @@
+/**
+ * PostgreSQL Memory Store with pgvector
+ *
+ * Cloud-native memory backend for Railway deployments.
+ * Uses pgvector extension for efficient vector similarity search.
+ *
+ * Features:
+ * - All AdvancedMemoryStore features
+ * - Scalable Postgres backend
+ * - pgvector for vector similarity
+ * - Shared across multiple agent instances
+ */
+import pg from 'pg';
+const { Pool } = pg;
+// Simple local embedding using character n-grams (same as SQLite version)
+function computeEmbedding(text, dimensions = 384) {
+    const embedding = new Array(dimensions).fill(0);
+    const normalized = text.toLowerCase();
+    // Character trigrams
+    for (let i = 0; i < normalized.length - 2; i++) {
+        const trigram = normalized.slice(i, i + 3);
+        const hash = hashString(trigram);
+        const idx = Math.abs(hash) % dimensions;
+        embedding[idx] += 1;
+    }
+    // Word unigrams
+    const words = normalized.split(/\s+/);
+    for (const word of words) {
+        const hash = hashString(word);
+        const idx = Math.abs(hash) % dimensions;
+        embedding[idx] += 2;
+    }
+    // Normalize
+    const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+    if (magnitude > 0) {
+        for (let i = 0; i < embedding.length; i++) {
+            embedding[i] /= magnitude;
+        }
+    }
+    return embedding;
+}
+function hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return hash;
+}
+export class PostgresMemoryStore {
+    pool;
+    userId;
+    dimensions;
+    initialized = false;
+    constructor(config) {
+        this.pool = new Pool({
+            connectionString: config.connectionString,
+            ssl: { rejectUnauthorized: false } // Required for Railway
+        });
+        this.userId = config.userId || 'default';
+        this.dimensions = config.dimensions || 384;
+    }
+    /**
+     * Initialize database schema
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        const client = await this.pool.connect();
+        try {
+            // Enable pgvector extension
+            await client.query('CREATE EXTENSION IF NOT EXISTS vector');
+            // Create memories table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS memories (
+          id TEXT PRIMARY KEY,
+          user_id TEXT NOT NULL,
+          type TEXT NOT NULL,
+          content TEXT NOT NULL,
+          summary TEXT,
+          source TEXT,
+          timestamp TIMESTAMPTZ DEFAULT NOW(),
+          last_accessed TIMESTAMPTZ DEFAULT NOW(),
+          importance REAL DEFAULT 0.5,
+          access_count INTEGER DEFAULT 0,
+          decay_rate REAL DEFAULT 0.01,
+          associations TEXT[] DEFAULT '{}',
+          tags TEXT[] DEFAULT '{}',
+          embedding vector(${this.dimensions}),
+          created_at TIMESTAMPTZ DEFAULT NOW()
+        )
+      `);
+            // Create indexes
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_memories_user_id ON memories(user_id)
+      `);
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type)
+      `);
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance DESC)
+      `);
+            // Create vector similarity index (IVFFlat for performance)
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_memories_embedding
+        ON memories USING ivfflat (embedding vector_cosine_ops)
+        WITH (lists = 100)
+      `).catch(() => {
+                // IVFFlat requires at least 100 rows, fall back to exact search
+                console.log('[POSTGRES] IVFFlat index skipped (will use exact search)');
+            });
+            this.initialized = true;
+            console.log('[POSTGRES] Memory store initialized');
+        }
+        finally {
+            client.release();
+        }
+    }
+    /**
+     * Store a memory
+     */
+    async remember(content, options) {
+        await this.initialize();
+        const id = `mem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const type = options?.type || this.inferType(content);
+        const importance = options?.importance ?? this.calculateImportance(content);
+        const embedding = computeEmbedding(content, this.dimensions);
+        await this.pool.query(`
+      INSERT INTO memories (id, user_id, type, content, source, importance, tags, embedding)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+    `, [
+            id,
+            this.userId,
+            type,
+            content,
+            options?.source || 'user',
+            importance,
+            options?.tags || [],
+            `[${embedding.join(',')}]`
+        ]);
+        console.log(`[POSTGRES] Stored memory ${id} (${type}, importance=${importance.toFixed(2)})`);
+        return id;
+    }
+    /**
+     * Search memories using vector similarity
+     */
+    async search(query, options) {
+        await this.initialize();
+        const embedding = computeEmbedding(query, this.dimensions);
+        const limit = options?.limit || 10;
+        const minImportance = options?.minImportance || 0;
+        let sql = `
+      SELECT
+        id, type, content, summary, source, timestamp, last_accessed,
+        importance, access_count, decay_rate, associations, tags,
+        1 - (embedding <=> $1::vector) as similarity
+      FROM memories
+      WHERE user_id = $2
+        AND importance >= $3
+    `;
+        const params = [
+            `[${embedding.join(',')}]`,
+            this.userId,
+            minImportance
+        ];
+        if (options?.type) {
+            sql += ` AND type = $${params.length + 1}`;
+            params.push(options.type);
+        }
+        sql += ` ORDER BY similarity DESC LIMIT $${params.length + 1}`;
+        params.push(limit);
+        const result = await this.pool.query(sql, params);
+        // Update access counts for retrieved memories
+        if (result.rows.length > 0) {
+            const ids = result.rows.map(r => r.id);
+            await this.pool.query(`
+        UPDATE memories
+        SET access_count = access_count + 1,
+            last_accessed = NOW()
+        WHERE id = ANY($1)
+      `, [ids]);
+        }
+        return result.rows.map(row => ({
+            id: row.id,
+            type: row.type,
+            content: row.content,
+            summary: row.summary,
+            source: row.source,
+            timestamp: row.timestamp.toISOString(),
+            lastAccessed: row.last_accessed.toISOString(),
+            importance: row.importance,
+            accessCount: row.access_count,
+            decayRate: row.decay_rate,
+            associations: row.associations || [],
+            tags: row.tags || [],
+            hasEmbedding: true
+        }));
+    }
+    /**
+     * Get memory by ID
+     */
+    async get(id) {
+        await this.initialize();
+        const result = await this.pool.query(`
+      SELECT * FROM memories WHERE id = $1 AND user_id = $2
+    `, [id, this.userId]);
+        if (result.rows.length === 0)
+            return null;
+        const row = result.rows[0];
+        return {
+            id: row.id,
+            type: row.type,
+            content: row.content,
+            summary: row.summary,
+            source: row.source,
+            timestamp: row.timestamp.toISOString(),
+            lastAccessed: row.last_accessed.toISOString(),
+            importance: row.importance,
+            accessCount: row.access_count,
+            decayRate: row.decay_rate,
+            associations: row.associations || [],
+            tags: row.tags || [],
+            hasEmbedding: true
+        };
+    }
+    /**
+     * Delete a memory
+     */
+    async forget(id) {
+        await this.initialize();
+        const result = await this.pool.query(`
+      DELETE FROM memories WHERE id = $1 AND user_id = $2
+    `, [id, this.userId]);
+        return (result.rowCount ?? 0) > 0;
+    }
+    /**
+     * Update memory importance
+     */
+    async reinforce(id, boost = 0.1) {
+        await this.initialize();
+        await this.pool.query(`
+      UPDATE memories
+      SET importance = LEAST(1.0, importance + $1)
+      WHERE id = $2 AND user_id = $3
+    `, [boost, id, this.userId]);
+    }
+    /**
+     * Get memory statistics
+     */
+    stats() {
+        // This is synchronous in the interface, but we need async for Postgres
+        // Return cached stats or default values
+        return this._cachedStats || {
+            total: 0,
+            byType: { episodic: 0, semantic: 0, procedural: 0, working: 0 },
+            avgImportance: 0.5,
+            totalAssociations: 0
+        };
+    }
+    _cachedStats = null;
+    /**
+     * Update stats cache (call periodically)
+     */
+    async updateStatsCache() {
+        await this.initialize();
+        const result = await this.pool.query(`
+      SELECT
+        COUNT(*) as total,
+        AVG(importance) as avg_importance,
+        SUM(array_length(associations, 1)) as total_associations
+      FROM memories
+      WHERE user_id = $1
+    `, [this.userId]);
+        const typeResult = await this.pool.query(`
+      SELECT type, COUNT(*) as count
+      FROM memories
+      WHERE user_id = $1
+      GROUP BY type
+    `, [this.userId]);
+        const byType = {
+            episodic: 0, semantic: 0, procedural: 0, working: 0
+        };
+        for (const row of typeResult.rows) {
+            byType[row.type] = parseInt(row.count);
+        }
+        this._cachedStats = {
+            total: parseInt(result.rows[0].total) || 0,
+            byType,
+            avgImportance: parseFloat(result.rows[0].avg_importance) || 0.5,
+            totalAssociations: parseInt(result.rows[0].total_associations) || 0
+        };
+    }
+    /**
+     * Apply temporal decay to all memories
+     */
+    async applyDecay() {
+        await this.initialize();
+        await this.pool.query(`
+      UPDATE memories
+      SET importance = GREATEST(0.1, importance * (1 - decay_rate))
+      WHERE user_id = $1
+        AND importance > 0.1
+        AND last_accessed < NOW() - INTERVAL '1 day'
+    `, [this.userId]);
+    }
+    /**
+     * Cleanup old low-importance memories
+     */
+    async cleanup(options) {
+        await this.initialize();
+        const maxAgeDays = (options?.maxAge || 30 * 24 * 60 * 60 * 1000) / (1000 * 60 * 60 * 24);
+        const minImportance = options?.minImportance || 0.2;
+        const result = await this.pool.query(`
+      DELETE FROM memories
+      WHERE user_id = $1
+        AND importance < $2
+        AND last_accessed < NOW() - INTERVAL '1 day' * $3
+    `, [this.userId, minImportance, maxAgeDays]);
+        const count = result.rowCount ?? 0;
+        if (count > 0) {
+            console.log(`[POSTGRES] Cleaned up ${count} old memories`);
+        }
+        return count;
+    }
+    /**
+     * Close the connection pool
+     */
+    async close() {
+        await this.pool.end();
+        console.log('[POSTGRES] Connection pool closed');
+    }
+    // Helper methods
+    inferType(content) {
+        const lower = content.toLowerCase();
+        // Procedural indicators
+        if (lower.includes('how to') || lower.includes('steps to') ||
+            lower.includes('process for') || lower.includes('when doing')) {
+            return 'procedural';
+        }
+        // Episodic indicators (past tense, specific events)
+        if (lower.includes('yesterday') || lower.includes('last week') ||
+            lower.includes('we did') || lower.includes('happened')) {
+            return 'episodic';
+        }
+        // Default to semantic (facts)
+        return 'semantic';
+    }
+    calculateImportance(content) {
+        let importance = 0.5;
+        // Boost for longer, detailed content
+        if (content.length > 200)
+            importance += 0.1;
+        if (content.length > 500)
+            importance += 0.1;
+        // Boost for structured content
+        if (content.includes(':') || content.includes('-') || content.includes('•')) {
+            importance += 0.1;
+        }
+        // Boost for preference indicators
+        const lower = content.toLowerCase();
+        if (lower.includes('prefer') || lower.includes('always') ||
+            lower.includes('never') || lower.includes('important')) {
+            importance += 0.15;
+        }
+        return Math.min(1.0, importance);
+    }
+}
+/**
+ * Check if Postgres is available and configured
+ */
+export function isPostgresConfigured() {
+    return !!process.env.DATABASE_URL;
+}

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.11'; // 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.11",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",
@@ -43,6 +43,7 @@
     "conf": "^13.0.1",
     "node-cron": "^3.0.3",
     "ora": "^8.1.1",
+    "pg": "^8.13.1",
     "vectra": "^0.9.0",
     "ws": "^8.18.3"
   },
@@ -50,6 +51,7 @@
     "@types/better-sqlite3": "^7.6.12",
     "@types/node": "^22.10.2",
     "@types/node-cron": "^3.0.11",
+    "@types/pg": "^8.11.10",
     "@types/ws": "^8.18.1",
     "typescript": "^5.7.2"
   }