@rigstate/cli 0.7.21 → 0.7.22

package/package.json

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

package/src/daemon/core.ts

@@ -20,6 +20,7 @@ import { DaemonConfig, DaemonState } from './types.js';
 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';
 
 export class GuardianDaemon extends EventEmitter {
     private config: DaemonConfig;
@@ -60,10 +61,10 @@ export class GuardianDaemon extends EventEmitter {
 
         // 2. Load and Sync Rules
         await this.guardianMonitor.loadRules();
-        console.log(chalk.green(`  ✓ Loaded ${this.guardianMonitor.getRuleCount()} rules`));
+        Logger.info(`Loaded ${this.guardianMonitor.getRuleCount()} rules`);
 
         // Auto-Sync Brain to IDE (The "Missing Link")
-        console.log(chalk.dim('🧠 Syncing Brain to IDE (.cursor/rules)...'));
+        Logger.info('Syncing Brain to IDE (.cursor/rules)...');
         await syncProjectRules(this.config.projectId, this.config.apiKey, this.config.apiUrl);
 
         await this.syncHeuristics();
@@ -104,65 +105,83 @@ export class GuardianDaemon extends EventEmitter {
     private async syncHeuristics() {
         if (!this.heuristicEngine) return;
         const synced = await this.heuristicEngine.refreshRules(this.config.projectId, this.config.apiUrl, this.config.apiKey);
-        if (synced) console.log(chalk.green('  ✓ Synced heuristic rules'));
+        if (synced) Logger.info('Synced heuristic rules');
     }
 
     private setupFileWatcher() {
-        console.log(chalk.dim('📂 Starting file watcher...'));
+        Logger.info('Starting file watcher...');
         this.fileWatcher = createFileWatcher(this.config.watchPath);
         this.fileWatcher.on('change', (path) => this.handleFileChange(path));
         this.fileWatcher.start();
-        console.log(chalk.green('  ✓ File watcher active'));
+        Logger.info('File watcher active');
     }
 
     private async handleFileChange(filePath: string) {
         this.state.lastActivity = new Date().toISOString();
-        if (this.config.verbose) console.log(chalk.dim(`  📝 File changed: ${filePath}`));
+        if (this.config.verbose) Logger.debug(`File changed: ${filePath}`);
 
-        // 1. Calculate metrics
-        let lineCount = 0;
+        const lineCount = await this.getLineCount(filePath);
+
+        // A. Predictive Analysis
+        await this.runPredictiveAnalysis(filePath, lineCount);
+
+        // B. Integrity Check
+        await this.runIntegrityCheck(filePath);
+    }
+
+    private async getLineCount(filePath: string): Promise<number> {
         try {
             const content = await fs.readFile(filePath, 'utf-8');
-            lineCount = content.split('\n').length;
-        } catch (e) { /* Deleted file or error */ }
-
-        // A. Prediction & JIT
-        if (this.heuristicEngine && this.interventionProtocol && this.guardianMonitor) {
-            const matches = await this.heuristicEngine.analyzeFile(filePath, {
-                lineCount,
-                rules: this.guardianMonitor.getRules()
-            });
-            for (const match of matches) {
-                console.log(chalk.magenta(`  💡 PREDICTIVE ACTIVATION: ${match.skillId}`));
-                console.log(chalk.dim(`     Reason: ${match.reason}`));
-
-                const decision = this.interventionProtocol.evaluateTrigger(match.skillId, match.confidence);
-                this.interventionProtocol.enforce(decision);
+            return content.split('\n').length;
+        } catch (e) {
+            return 0;
+        }
+    }
 
-                await jitProvisionSkill(match.skillId, this.config.apiUrl, this.config.apiKey, this.config.projectId, process.cwd());
-                await trackSkillUsage(this.config.apiUrl, this.config.apiKey, this.config.projectId, match.skillId);
-                this.emit('skill:suggestion', match);
-            }
+    private async runPredictiveAnalysis(filePath: string, lineCount: number) {
+        if (!this.heuristicEngine || !this.interventionProtocol || !this.guardianMonitor) return;
+
+        const matches = await this.heuristicEngine.analyzeFile(filePath, {
+            lineCount,
+            rules: this.guardianMonitor.getRules()
+        });
+
+        for (const match of matches) {
+            Logger.info(`PREDICTIVE ACTIVATION: ${match.skillId} (${match.reason})`);
+
+            const decision = this.interventionProtocol.evaluateTrigger(match.skillId, match.confidence);
+            this.interventionProtocol.enforce(decision);
+
+            await jitProvisionSkill(match.skillId, this.config.apiUrl, this.config.apiKey, this.config.projectId, process.cwd());
+            await trackSkillUsage(this.config.apiUrl, this.config.apiKey, this.config.projectId, match.skillId);
+            this.emit('skill:suggestion', match);
         }
+    }
 
-        // B. Guardian Check
-        if (this.guardianMonitor) {
-            if (this.interventionProtocol) this.interventionProtocol.clear(filePath);
-            const result = await this.guardianMonitor.checkFile(filePath);
-            this.state.filesChecked++;
-
-            if (result.violations.length > 0) {
-                this.state.violationsFound += result.violations.length;
-                this.emit('violation', { file: filePath, violations: result.violations });
-                for (const v of result.violations) {
-                    const color = v.severity === 'critical' ? chalk.red : v.severity === 'warning' ? chalk.yellow : chalk.blue;
-                    console.log(color(`  [${v.severity.toUpperCase()}] ${filePath}: ${v.message}`));
-                    if (this.interventionProtocol) {
-                        const decision = this.interventionProtocol.evaluateViolation(v.message, v.severity as any);
-                        this.interventionProtocol.enforce(decision);
-                        this.interventionProtocol.registerViolation(filePath, decision);
-                    }
-                }
+    private async runIntegrityCheck(filePath: string) {
+        if (!this.guardianMonitor) return;
+
+        if (this.interventionProtocol) this.interventionProtocol.clear(filePath);
+        const result = await this.guardianMonitor.checkFile(filePath);
+        this.state.filesChecked++;
+
+        if (result.violations.length > 0) {
+            this.handleViolations(filePath, result.violations);
+        }
+    }
+
+    private handleViolations(filePath: string, violations: any[]) {
+        this.state.violationsFound += violations.length;
+        this.emit('violation', { file: filePath, violations });
+
+        for (const v of violations) {
+            const level = v.severity === 'critical' ? 'error' : v.severity === 'warning' ? 'warn' : 'info';
+            Logger[level as 'info'](`[${v.severity.toUpperCase()}] ${filePath}: ${v.message}`);
+
+            if (this.interventionProtocol) {
+                const decision = this.interventionProtocol.evaluateViolation(v.message, v.severity as any);
+                this.interventionProtocol.enforce(decision);
+                this.interventionProtocol.registerViolation(filePath, decision);
             }
         }
     }