@rigstate/cli 0.7.21 → 0.7.23

package/package.json

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

package/src/commands/link.ts

@@ -30,12 +30,17 @@ export function createLinkCommand() {
 
             const manifestPath = path.join(process.cwd(), '.rigstate');
 
-            const content = {
+            const content: any = {
                 project_id: projectId,
-                api_url: getApiUrl(),
                 linked_at: new Date().toISOString()
             };
 
+            // Only store api_url locally if it's NOT the production default
+            const currentUrl = getApiUrl();
+            if (currentUrl !== 'https://app.rigstate.com') {
+                content.api_url = currentUrl;
+            }
+
             try {
                 await fs.writeFile(manifestPath, JSON.stringify(content, null, 2), 'utf-8');
                 console.log(chalk.green(`✔ Linked to project ID: ${projectId}`));
@@ -105,10 +110,6 @@ async function installHooks(cwd: string) {
     // Actually, let's just use the `hooks` command logic if possible, or a lightweight version
 
     try {
-        const { installHooks: runInstall } = await import('./hooks.js');
-        // We need to mock the command context or extract logic. 
-        // For simplicity/robustness in this iteration, let's just suggest it or verify
-
         // Simpler approach: Check if pre-commit exists
         const preCommitPath = path.join(cwd, '.git/hooks/pre-commit');
         try {

package/src/commands/mcp.ts

@@ -4,6 +4,7 @@ import { spawn } from 'child_process';
 import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
+import { getApiKey, getApiUrl } from '../utils/config.js';
 
 // ESM compatibility for __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -45,15 +46,29 @@ export function createMcpCommand() {
 
             console.log(chalk.dim(`Starting MCP server from: ${serverPath}`));
 
-            // Map VIBE_API_KEY to RIGSTATE_API_KEY if needed (backwards compatibility)
-            if (process.env.VIBE_API_KEY && !process.env.RIGSTATE_API_KEY) {
-                process.env.RIGSTATE_API_KEY = process.env.VIBE_API_KEY;
+            // SMART INJECTION: Inject global config into MCP environment
+            const env = { ...process.env };
+
+            try {
+                const apiKey = getApiKey();
+                if (apiKey) {
+                    env.RIGSTATE_API_KEY = apiKey;
+                    // Also inject the URL for consistency
+                    env.RIGSTATE_APP_URL = getApiUrl();
+                    env.RIGSTATE_API_URL = getApiUrl();
+                }
+            } catch (e) {
+                // If not logged in, we carry on and let the MCP server show the final error
+            }
+
+            // Map VIBE_API_KEY if needed
+            if (env.VIBE_API_KEY && !env.RIGSTATE_API_KEY) {
+                env.RIGSTATE_API_KEY = env.VIBE_API_KEY;
             }
 
             // Spawn the MCP server as a child process
-            // MCP uses stdio for communication, so we inherit it
             const worker = spawn('node', [serverPath], {
-                env: process.env,
+                env,
                 stdio: ['inherit', 'inherit', 'inherit']
             });
 

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);
             }
         }
     }

package/.rigstate/daemon.pid

@@ -1 +0,0 @@
-32037