@rigstate/cli 0.7.29 → 0.7.31

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rigstate/cli",
-    "version": "0.7.29",
+    "version": "0.7.31",
     "description": "Rigstate CLI - Code audit, sync and supervision tool",
     "type": "module",
     "main": "./dist/index.js",

package/src/daemon/core.ts

@@ -22,6 +22,7 @@ import { trackSkillUsage } from './telemetry.js';
 import { jitProvisionSkill } from '../utils/skills-provisioner.js';
 import { syncProjectRules } from '../commands/sync-rules.js';
 import { Logger } from '../utils/logger.js';
+import { KnowledgeHarvester } from './harvester.js';
 
 export class GuardianDaemon extends EventEmitter {
     private config: DaemonConfig;
@@ -31,6 +32,8 @@ export class GuardianDaemon extends EventEmitter {
     private heuristicEngine: ReturnType<typeof createHeuristicEngine> | null = null;
     private interventionProtocol: ReturnType<typeof createInterventionProtocol> | null = null;
     private bridgeListener: ReturnType<typeof createBridgeListener> | null = null;
+    private harvester: KnowledgeHarvester | null = null;
+    private syncInterval: NodeJS.Timeout | null = null;
 
     constructor(config: DaemonConfig) {
         super();
@@ -60,19 +63,35 @@ export class GuardianDaemon extends EventEmitter {
         this.interventionProtocol = createInterventionProtocol();
         this.guardianMonitor = createGuardianMonitor(this.config.projectId, this.config.apiUrl, this.config.apiKey);
 
+        // Initialize Harvester 🌾
+        this.harvester = new KnowledgeHarvester({
+            projectId: this.config.projectId,
+            apiUrl: this.config.apiUrl,
+            apiKey: this.config.apiKey,
+            watchPath: process.cwd()
+        });
+
         // 2. Load and Sync Rules
         await this.guardianMonitor.loadRules();
         Logger.info(`Loaded ${this.guardianMonitor.getRuleCount()} rules`);
 
         // Auto-Sync Brain to IDE (The "Missing Link")
         Logger.info('Syncing Brain to IDE (.cursor/rules)...');
-        await syncProjectRules(this.config.projectId, this.config.apiKey, this.config.apiUrl);
+        await this.runRuleSync(); // Initial sync
 
         await this.syncHeuristics();
 
         // 3. Setup File Watcher
         if (this.config.checkOnChange) {
             this.setupFileWatcher();
+            // Start Harvester
+            await this.harvester.start();
+
+            // Start Auto-Sync Poller (Every 5 minutes)
+            Logger.info('Starting Auto-Sync Poller (5m interval)...');
+            this.syncInterval = setInterval(() => {
+                this.runRuleSync().catch(e => Logger.error(`Auto-Sync failed: ${e.message}`));
+            }, 5 * 60 * 1000);
         }
 
         // 4. Setup Bridge
@@ -90,6 +109,19 @@ export class GuardianDaemon extends EventEmitter {
         this.emit('started', this.state);
     }
 
+    private async runRuleSync() {
+        try {
+            // We use the existing syncProjectRules command logic
+            // Ideally we should silent the spinner output for background runs
+            // For now, we utilize it "as is" but maybe we capture logs if needed
+            // TODO: Refactor syncProjectRules to be less verbose in daemon mode
+            await syncProjectRules(this.config.projectId, this.config.apiKey, this.config.apiUrl);
+            Logger.debug('Auto-Sync completed successfully');
+        } catch (error: any) {
+            Logger.warn(`Rule sync hiccup: ${error.message}`);
+        }
+    }
+
     private printWelcome() {
         console.log(chalk.bold.blue('\n🛡️  Guardian Daemon Starting...'));
         console.log(chalk.dim(`Project: ${this.config.projectId}`));
@@ -251,6 +283,11 @@ export class GuardianDaemon extends EventEmitter {
         console.log(chalk.dim('\n🛑 Stopping Guardian Daemon...'));
         if (this.fileWatcher) await this.fileWatcher.stop();
         if (this.bridgeListener) await this.bridgeListener.disconnect();
+
+        // Cleanup new components
+        if (this.harvester) await this.harvester.stop();
+        if (this.syncInterval) clearInterval(this.syncInterval);
+
         this.state.isRunning = false;
         console.log(chalk.green('✓ Daemon stopped.'));
         this.emit('stopped', this.state);

package/src/daemon/harvester.ts

@@ -0,0 +1,199 @@
+import { EventEmitter } from 'events';
+import chokidar from 'chokidar';
+import path from 'path';
+import fs from 'fs/promises';
+import crypto from 'crypto';
+import axios from 'axios';
+import { Logger } from '../utils/logger.js';
+
+export interface HarvesterConfig {
+    projectId: string;
+    apiUrl: string;
+    apiKey: string;
+    watchPath: string; // usually process.cwd()
+}
+
+/**
+ * The Knowledge Harvester 🌾
+ * 
+ * Watches the local rule repositories (.cursor/rules/*.mdc) for new patterns
+ * or corrections that the user teaches their local AI agent.
+ * 
+ * When a new insight is detected, it is harvested (read), validated,
+ * and shipped to the Rigstate Curator Protocol as a signal.
+ */
+export class KnowledgeHarvester extends EventEmitter {
+    private watcher: chokidar.FSWatcher | null = null;
+    private config: HarvesterConfig;
+    private ruleHashes: Map<string, string> = new Map();
+    private isReady: boolean = false;
+    private processingQueue: Set<string> = new Set();
+    private debounceTimers: Map<string, NodeJS.Timeout> = new Map();
+
+    // Ignore list to prevent feedback loops with system rules
+    private IGNORED_PREFIXES = ['rigstate-identity', 'rigstate-guardian'];
+
+    constructor(config: HarvesterConfig) {
+        super();
+        this.config = config;
+    }
+
+    async start() {
+        // Load initial state to establish baseline (don't harvest initial load)
+        await this.loadHashes();
+
+        const rulesPath = path.join(this.config.watchPath, '.cursor', 'rules');
+        const watchPattern = path.join(rulesPath, '**', '*.mdc');
+
+        Logger.debug(`🌾 Harvester watching: ${watchPattern}`);
+
+        this.watcher = chokidar.watch(watchPattern, {
+            persistent: true,
+            ignoreInitial: true, // Don't harvest what's already there on boot
+            awaitWriteFinish: {
+                stabilityThreshold: 2000,
+                pollInterval: 100
+            }
+        });
+
+        this.watcher
+            .on('add', (path) => this.handleFileEvent(path, 'add'))
+            .on('change', (path) => this.handleFileEvent(path, 'change')); // We treat change same as add (new version of truth)
+
+        this.isReady = true;
+    }
+
+    async stop() {
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+        // Save state? Maybe not needed as we re-hash on boot.
+    }
+
+    private async handleFileEvent(filePath: string, event: 'add' | 'change') {
+        const fileName = path.basename(filePath);
+
+        // 1. Filter ignored files
+        if (this.IGNORED_PREFIXES.some(prefix => fileName.startsWith(prefix))) {
+            return;
+        }
+
+        // 2. Debounce (users save frequently)
+        if (this.debounceTimers.has(filePath)) {
+            clearTimeout(this.debounceTimers.get(filePath));
+        }
+
+        this.debounceTimers.set(filePath, setTimeout(async () => {
+            this.processFile(filePath);
+            this.debounceTimers.delete(filePath);
+        }, 5000)); // 5 second quiet period
+    }
+
+    private async processFile(filePath: string) {
+        if (this.processingQueue.has(filePath)) return;
+        this.processingQueue.add(filePath);
+
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const currentHash = this.computeHash(content);
+
+            // 3. Check against memory (did we just harvest this?)
+            // We also need to check against the server-sync cache (did we just download this?)
+            // For now, simple memory check.
+            if (this.ruleHashes.get(filePath) === currentHash) {
+                Logger.debug(`Skipping ${path.basename(filePath)} (unchanged hash)`);
+                return;
+            }
+
+            // 4. Validate Content
+            if (content.length < 20) {
+                Logger.debug(`Skipping ${path.basename(filePath)} (too short)`);
+                return;
+            }
+
+            // 5. Submit Signal
+            await this.submitSignal(filePath, content);
+
+            // 6. Update Hash
+            this.ruleHashes.set(filePath, currentHash);
+
+        } catch (error: any) {
+            Logger.warn(`Harvester failed to process ${path.basename(filePath)}: ${error.message}`);
+        } finally {
+            this.processingQueue.delete(filePath);
+        }
+    }
+
+    private async submitSignal(filePath: string, content: string) {
+        const title = path.basename(filePath, '.mdc');
+        const relativePath = path.relative(process.cwd(), filePath);
+
+        Logger.info(`🌾 Harvesting new knowledge: ${title}`);
+
+        try {
+            // NOTE: We're using the 'mcp_submit_curator_signal' endpoint logic here
+            // URL: /api/v1/curator/signals (Assumed endpoint based on user request)
+
+            // Extract frontmatter description if possible
+            const descriptionMatch = content.match(/description:\s*(.*)/);
+            const description = descriptionMatch ? descriptionMatch[1].trim() : "Auto-harvested from IDE interaction";
+
+            const payload = {
+                project_id: this.config.projectId,
+                title: title,
+                category: 'ARCHITECTURE', // Default
+                severity: 'MEDIUM',
+                instruction: content,
+                reasoning: `Harvested from local file: ${relativePath}`,
+                source_type: 'IDE_HARVESTER'
+            };
+
+            const response = await axios.post(`${this.config.apiUrl}/api/v1/curator/signals`, payload, {
+                headers: { Authorization: `Bearer ${this.config.apiKey}` }
+            });
+
+            if (response.data.success) {
+                Logger.info(`✅ Signal submitted for review: ${title}`);
+            } else {
+                throw new Error(response.data.error || 'Unknown API error');
+            }
+
+        } catch (error: any) {
+            if (error.response?.status === 404) {
+                // API endpoint might not exist yet during migration
+                Logger.debug('Curator API not reachable (404). Signal stored locally (mock).');
+            } else {
+                Logger.error(`Failed to submit signal: ${error.message}`);
+                // Don't update hash so we try again next edit
+                this.ruleHashes.delete(filePath);
+                throw error; // Re-throw to catch block
+            }
+        }
+    }
+
+    private async loadHashes() {
+        // Initial scan to build baseline so we don't upload everything on start
+        const rulesPath = path.join(this.config.watchPath, '.cursor', 'rules');
+        try {
+            // Ensure dir exists
+            await fs.mkdir(rulesPath, { recursive: true });
+
+            // This is a simplified recursive walk since we know structure is flat usually
+            const files = await fs.readdir(rulesPath);
+            for (const file of files) {
+                if (file.endsWith('.mdc')) {
+                    const fullPath = path.join(rulesPath, file);
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    this.ruleHashes.set(fullPath, this.computeHash(content));
+                }
+            }
+        } catch (e) {
+            // Directory might not exist yet, that's fine
+        }
+    }
+
+    private computeHash(content: string): string {
+        return crypto.createHash('sha256').update(content).digest('hex');
+    }
+}

package/src/index.ts

@@ -61,7 +61,6 @@ program.addCommand(createOverrideCommand());
 program.addCommand(createIdeaCommand());
 program.addCommand(createReleaseCommand());
 program.addCommand(createRoadmapCommand());
-program.addCommand(createRoadmapCommand());
 program.addCommand(createCouncilCommand());
 program.addCommand(createPlanCommand());