@rigstate/cli 0.6.0

package/src/commands/work.ts

@@ -0,0 +1,172 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import axios from 'axios';
+import inquirer from 'inquirer';
+import fs from 'fs/promises';
+import path from 'path';
+import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+
+export function createWorkCommand(): Command {
+    return new Command('work')
+        .alias('start')
+        .description('Select and execute a Roadmap Task (fetches IDE Prompt)')
+        .argument('[taskId]', 'Optional Task ID (e.g., T-1021) to start immediately')
+        .option('--project <id>', 'Project ID')
+        .action(async (taskId: string | undefined, options: { project?: string }) => {
+            const spinner = ora();
+
+            try {
+                const apiKey = getApiKey();
+                const apiUrl = getApiUrl();
+                const projectId = options.project || getProjectId();
+
+                if (!projectId) {
+                    console.log(chalk.red('❌ Project ID is required. Run `rigstate link` or pass --project <id>'));
+                    process.exit(1);
+                }
+
+                if (!taskId) {
+                    spinner.start('Fetching active roadmap tasks...');
+                }
+
+                // 1. Fetch Roadmap
+                const response = await axios.get(
+                    `${apiUrl}/api/v1/roadmap?project_id=${projectId}`,
+                    { headers: { 'Authorization': `Bearer ${apiKey}` }, timeout: 10000 }
+                );
+
+                if (!response.data.success) {
+                    throw new Error(response.data.error || 'Failed to fetch roadmap');
+                }
+
+                const allTasks: any[] = response.data.data.roadmap || [];
+
+                // 2. Filter relevant tasks (ACTIVE or LOCKED or IN_PROGRESS if we had that status)
+                // We focus on ACTIVE (Started) and LOCKED (Next Up).
+                // Sort: ACTIVE first, then by step_number.
+                const actionableTasks = allTasks
+                    .filter(t => ['ACTIVE', 'LOCKED'].includes(t.status))
+                    .sort((a, b) => {
+                        if (a.status === 'ACTIVE' && b.status !== 'ACTIVE') return -1;
+                        if (b.status === 'ACTIVE' && a.status !== 'ACTIVE') return 1;
+                        return a.step_number - b.step_number;
+                    });
+
+                spinner.stop();
+
+                let selectedTask: any;
+
+                if (taskId) {
+                    // Direct Selection via Arg
+                    // taskId can be "T-1021" or just "1021" or the UUID
+                    selectedTask = allTasks.find(t =>
+                        t.id === taskId ||
+                        `T-${t.step_number}` === taskId ||
+                        t.step_number.toString() === taskId
+                    );
+
+                    if (!selectedTask) {
+                        console.log(chalk.red(`❌ Task '${taskId}' not found in roadmap.`));
+                        return;
+                    }
+                } else {
+                    // Interactive Selection
+                    if (actionableTasks.length === 0) {
+                        console.log(chalk.yellow('No active or locked tasks found. The Roadmap is clear! 🎉'));
+                        return;
+                    }
+
+                    const choices = actionableTasks.map(t => {
+                        const id = `T-${t.step_number}`;
+                        const statusIcon = t.status === 'ACTIVE' ? '▶️' : '🔒';
+                        const priority = t.priority === 'MVP' ? chalk.magenta('[MVP]') : chalk.blue(`[${t.priority}]`);
+
+                        return {
+                            name: `${statusIcon}  ${chalk.bold(id)}: ${t.title} ${priority}`,
+                            value: t,
+                            short: `${id}: ${t.title}`
+                        };
+                    });
+
+                    const answer = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'task',
+                        message: 'Which task are you working on?',
+                        choices,
+                        pageSize: 15
+                    }]);
+
+                    selectedTask = answer.task;
+                }
+
+                // 3. Display Task Context & Prompt
+                console.log('\n' + chalk.bold.underline(`🚀 WORK MODE: ${selectedTask.title}`));
+                console.log(chalk.dim(`ID: T-${selectedTask.step_number} | Status: ${selectedTask.status}`));
+
+                if (selectedTask.prompt_content) {
+                    console.log(chalk.yellow.bold('\n📋 IDE EXECUTION SIGNAL (Prompt):'));
+                    console.log(chalk.gray('--------------------------------------------------'));
+                    console.log(selectedTask.prompt_content);
+                    console.log(chalk.gray('--------------------------------------------------'));
+
+                    // Copy to clipboard option?
+                    // For now, let's offer to save it to a file which is more robust for Agents.
+
+                    const { action } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'action',
+                        message: 'What do you want to do?',
+                        choices: [
+                            { name: 'Copy Prompt (Print clean)', value: 'print' },
+                            { name: 'Create .cursorrules (Agent Context)', value: 'cursorrules' },
+                            { name: 'Mark as ACTIVE (if LOCKED)', value: 'activate' },
+                            { name: 'Mark as COMPLETED', value: 'complete' },
+                            { name: 'Cancel', value: 'cancel' }
+                        ]
+                    }]);
+
+                    if (action === 'cursorrules') {
+                        // Create a temporary .cursorrules or overwrite existing
+                        // Warning: this ignores strict existing cursorrules, maybe append?
+                        // For safety, let's create a .rigstate-context.md file
+                        await fs.writeFile('.rigstate-prompt.md', selectedTask.prompt_content);
+                        console.log(chalk.green(`✅ Prompt saved to ${chalk.bold('.rigstate-prompt.md')}`));
+                        console.log(chalk.dim('You can now reference this file in your IDE chat (@.rigstate-prompt.md)'));
+                    } else if (action === 'print') {
+                        console.log('\n' + selectedTask.prompt_content + '\n');
+                    } else if (action === 'activate' && selectedTask.status !== 'ACTIVE') {
+                        try {
+                            await axios.post(
+                                `${apiUrl}/api/v1/roadmap/update-status`,
+                                { step_id: selectedTask.id, status: 'ACTIVE', project_id: projectId },
+                                { headers: { 'Authorization': `Bearer ${apiKey}` } }
+                            );
+                            console.log(chalk.green(`✅ Task marked as ACTIVE.`));
+                        } catch (e: any) {
+                            console.error(chalk.red(`Failed to update status: ${e.message}`));
+                        }
+                    } else if (action === 'complete') {
+                        try {
+                            await axios.post(
+                                `${apiUrl}/api/v1/roadmap/update-status`,
+                                { step_id: selectedTask.id, status: 'COMPLETED', project_id: projectId },
+                                { headers: { 'Authorization': `Bearer ${apiKey}` } }
+                            );
+                            console.log(chalk.green(`✅ Task marked as COMPLETED. Great job!`));
+                        } catch (e: any) {
+                            console.error(chalk.red(`Failed to update status: ${e.message}`));
+                        }
+                    }
+
+                } else {
+                    console.log(chalk.yellow('\n⚠️  No specific IDE Prompt found for this task (Legacy Task?).'));
+                    console.log(chalk.dim('Objective: ' + (selectedTask.summary || selectedTask.description || 'Check web UI for details.')));
+                }
+
+            } catch (error: any) {
+                spinner.stop();
+                console.error(chalk.red(`\nCommand failed: ${error.message}`));
+            }
+        });
+}

package/src/daemon/bridge-listener.ts

@@ -0,0 +1,127 @@
+/**
+ * Bridge Listener - Connects to Agent Bridge for task polling
+ * 
+ * Uses polling as Supabase Realtime requires direct SDK access
+ * which is complex in CLI context. Polling every 5 seconds
+ * provides good responsiveness for task-based workflows.
+ */
+
+import axios from 'axios';
+import { EventEmitter } from 'events';
+
+export interface BridgeListenerEvents {
+    task: (task: BridgeTask) => void;
+    ping: () => void;
+    error: (error: Error) => void;
+    connected: () => void;
+    disconnected: () => void;
+}
+
+export interface BridgeTask {
+    id: string;
+    project_id: string;
+    task_id: string | null;
+    status: string;
+    proposal: string | null;
+    summary: string | null;
+    created_at: string;
+}
+
+export interface BridgeListener extends EventEmitter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    on<K extends keyof BridgeListenerEvents>(event: K, listener: BridgeListenerEvents[K]): this;
+    emit<K extends keyof BridgeListenerEvents>(event: K, ...args: Parameters<BridgeListenerEvents[K]>): boolean;
+}
+
+const POLL_INTERVAL_MS = 5000; // 5 seconds
+
+export function createBridgeListener(
+    projectId: string,
+    apiUrl: string,
+    apiKey: string
+): BridgeListener {
+    const emitter = new EventEmitter() as BridgeListener;
+    let pollInterval: NodeJS.Timeout | null = null;
+    let isConnected = false;
+    let lastCheckedId: string | null = null;
+
+    const checkBridge = async () => {
+        try {
+            const response = await axios.get(`${apiUrl}/api/v1/agent/bridge`, {
+                params: {
+                    project_id: projectId,
+                    action: 'check'
+                },
+                headers: { Authorization: `Bearer ${apiKey}` },
+                timeout: 10000
+            });
+
+            if (response.data.success && response.data.data?.task) {
+                const task = response.data.data.task;
+
+                // Check if this is a new task
+                if (task.id !== lastCheckedId) {
+                    lastCheckedId = task.id;
+
+                    // Check for ping/heartbeat
+                    if (task.proposal?.startsWith('ping')) {
+                        emitter.emit('ping');
+
+                        // Auto-acknowledge ping
+                        await acknowledgePing(task.id);
+                    } else {
+                        // Emit task for processing
+                        emitter.emit('task', task);
+                    }
+                }
+            }
+        } catch (error: any) {
+            // Don't emit error for network issues during polling
+            // as this is expected when offline
+            if (error.code !== 'ECONNREFUSED' && error.code !== 'ETIMEDOUT') {
+                emitter.emit('error', error);
+            }
+        }
+    };
+
+    const acknowledgePing = async (taskId: string) => {
+        try {
+            await axios.post(`${apiUrl}/api/v1/agent/bridge`, {
+                project_id: projectId,
+                action: 'update',
+                bridge_id: taskId,
+                status: 'COMPLETED',
+                summary: 'Pong! Guardian Daemon is active.'
+            }, {
+                headers: { Authorization: `Bearer ${apiKey}` },
+                timeout: 5000
+            });
+        } catch {
+            // Silently fail ping acknowledgment
+        }
+    };
+
+    emitter.connect = async () => {
+        if (isConnected) return;
+
+        // Initial check
+        await checkBridge();
+
+        // Start polling
+        pollInterval = setInterval(checkBridge, POLL_INTERVAL_MS);
+        isConnected = true;
+        emitter.emit('connected');
+    };
+
+    emitter.disconnect = async () => {
+        if (pollInterval) {
+            clearInterval(pollInterval);
+            pollInterval = null;
+        }
+        isConnected = false;
+        emitter.emit('disconnected');
+    };
+
+    return emitter;
+}

package/src/daemon/core.ts

@@ -0,0 +1,184 @@
+/**
+ * Daemon Core - Orchestrates all background watchers
+ * 
+ * Combines:
+ * 1. File Watcher (chokidar) - Monitors filesystem changes
+ * 2. Guardian Rules - Validates files against rules on change
+ * 3. Agent Bridge Listener - Receives tasks from Rigstate Cloud
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import * as fs from 'fs/promises';
+import { EventEmitter } from 'events';
+import { createFileWatcher, type FileWatcherEvents } from './file-watcher.js';
+import { createHeuristicEngine } from './heuristic-engine.js';
+import { createInterventionProtocol, type InterventionDecision } from './intervention-protocol.js';
+import { createGuardianMonitor } from './guardian-monitor.js';
+import { createBridgeListener, type BridgeListenerEvents } from './bridge-listener.js';
+import { DaemonConfig, DaemonState } from './types.js';
+import { trackSkillUsage } from './telemetry.js';
+import { jitProvisionSkill } from '../utils/skills-provisioner.js';
+
+export class GuardianDaemon extends EventEmitter {
+    private config: DaemonConfig;
+    private state: DaemonState;
+    private fileWatcher: ReturnType<typeof createFileWatcher> | null = null;
+    private guardianMonitor: ReturnType<typeof createGuardianMonitor> | null = null;
+    private heuristicEngine: ReturnType<typeof createHeuristicEngine> | null = null;
+    private interventionProtocol: ReturnType<typeof createInterventionProtocol> | null = null;
+    private bridgeListener: ReturnType<typeof createBridgeListener> | null = null;
+
+    constructor(config: DaemonConfig) {
+        super();
+        this.config = config;
+        this.state = {
+            isRunning: false,
+            startedAt: null,
+            filesChecked: 0,
+            violationsFound: 0,
+            tasksProcessed: 0,
+            lastActivity: null
+        };
+    }
+
+    async start(): Promise<void> {
+        if (this.state.isRunning) {
+            console.log(chalk.yellow('Daemon is already running.'));
+            return;
+        }
+
+        this.printWelcome();
+        this.state.isRunning = true;
+        this.state.startedAt = new Date().toISOString();
+
+        // 1. Initialize Engines
+        this.heuristicEngine = createHeuristicEngine();
+        this.interventionProtocol = createInterventionProtocol();
+        this.guardianMonitor = createGuardianMonitor(this.config.projectId, this.config.apiUrl, this.config.apiKey);
+
+        // 2. Load and Sync Rules
+        await this.guardianMonitor.loadRules();
+        console.log(chalk.green(`  ✓ Loaded ${this.guardianMonitor.getRuleCount()} rules`));
+        await this.syncHeuristics();
+
+        // 3. Setup File Watcher
+        if (this.config.checkOnChange) {
+            this.setupFileWatcher();
+        }
+
+        // 4. Setup Bridge
+        if (this.config.bridgeEnabled) {
+            await this.setupBridge();
+        }
+
+        this.printActive();
+        this.emit('started', this.state);
+    }
+
+    private printWelcome() {
+        console.log(chalk.bold.blue('\n🛡️  Guardian Daemon Starting...'));
+        console.log(chalk.dim(`Project: ${this.config.projectId}`));
+        console.log(chalk.dim(`Watch Path: ${this.config.watchPath}`));
+        console.log(chalk.dim('─'.repeat(50)));
+    }
+
+    private printActive() {
+        console.log(chalk.dim('─'.repeat(50)));
+        console.log(chalk.green.bold('✅ Guardian Daemon is now active'));
+        console.log(chalk.dim('Press Ctrl+C to stop\n'));
+    }
+
+    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'));
+    }
+
+    private setupFileWatcher() {
+        console.log(chalk.dim('📂 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'));
+    }
+
+    private async handleFileChange(filePath: string) {
+        this.state.lastActivity = new Date().toISOString();
+        if (this.config.verbose) console.log(chalk.dim(`  📝 File changed: ${filePath}`));
+
+        // 1. Calculate metrics
+        let lineCount = 0;
+        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);
+
+                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 setupBridge() {
+        console.log(chalk.dim('🌉 Connecting to Agent Bridge...'));
+        this.bridgeListener = createBridgeListener(this.config.projectId, this.config.apiUrl, this.config.apiKey);
+        this.bridgeListener.on('task', (task) => {
+            this.state.lastActivity = new Date().toISOString();
+            this.state.tasksProcessed++;
+            console.log(chalk.cyan(`\n📥 New task received: ${task.id}`));
+            this.emit('task', task);
+        });
+        await this.bridgeListener.connect();
+        console.log(chalk.green('  ✓ Agent Bridge connected'));
+    }
+
+    async stop(): Promise<void> {
+        if (!this.state.isRunning) return;
+        console.log(chalk.dim('\n🛑 Stopping Guardian Daemon...'));
+        if (this.fileWatcher) await this.fileWatcher.stop();
+        if (this.bridgeListener) await this.bridgeListener.disconnect();
+        this.state.isRunning = false;
+        console.log(chalk.green('✓ Daemon stopped.'));
+        this.emit('stopped', this.state);
+    }
+
+    getState(): DaemonState {
+        return { ...this.state };
+    }
+}

package/src/daemon/factory.ts

@@ -0,0 +1,45 @@
+import { GuardianDaemon } from './core.js';
+import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+import { loadManifest } from '../utils/manifest.js';
+import { DaemonConfig } from './types.js';
+
+/**
+ * Factory for creating a GuardianDaemon with resolved configuration.
+ */
+export async function createDaemon(options: {
+    project?: string;
+    path?: string;
+    noBridge?: boolean;
+    verbose?: boolean;
+}): Promise<GuardianDaemon> {
+    const apiUrl = getApiUrl();
+    let projectId = options.project;
+
+    if (!projectId) {
+        const manifest = await loadManifest();
+        if (manifest) projectId = manifest.project_id;
+    }
+
+    if (!projectId) projectId = getProjectId();
+
+    if (!projectId) {
+        throw new Error('No project ID found. Run "rigstate link" or use --project <id>.');
+    }
+
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        throw new Error('Not authenticated. Run "rigstate login" first.');
+    }
+
+    const config: DaemonConfig = {
+        projectId,
+        apiUrl,
+        apiKey,
+        watchPath: options.path || process.cwd(),
+        checkOnChange: true,
+        bridgeEnabled: !options.noBridge,
+        verbose: !!options.verbose
+    };
+
+    return new GuardianDaemon(config);
+}

package/src/daemon/file-watcher.ts

@@ -0,0 +1,97 @@
+/**
+ * File Watcher - Monitors filesystem for changes using chokidar
+ */
+
+import * as chokidar from 'chokidar';
+import path from 'path';
+import { EventEmitter } from 'events';
+
+export interface FileWatcherEvents {
+    change: (filePath: string) => void;
+    add: (filePath: string) => void;
+    unlink: (filePath: string) => void;
+    error: (error: Error) => void;
+    ready: () => void;
+}
+
+export interface FileWatcher extends EventEmitter {
+    start(): void;
+    stop(): Promise<void>;
+    on<K extends keyof FileWatcherEvents>(event: K, listener: FileWatcherEvents[K]): this;
+    emit<K extends keyof FileWatcherEvents>(event: K, ...args: Parameters<FileWatcherEvents[K]>): boolean;
+}
+
+const CODE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+
+function isCodeFile(filePath: string): boolean {
+    const ext = path.extname(filePath).toLowerCase();
+    return CODE_EXTENSIONS.includes(ext);
+}
+
+export function createFileWatcher(watchPath: string): FileWatcher {
+    const emitter = new EventEmitter() as FileWatcher;
+    let watcher: chokidar.FSWatcher | null = null;
+
+    emitter.start = () => {
+        const absolutePath = path.resolve(process.cwd(), watchPath);
+
+        watcher = chokidar.watch(absolutePath, {
+            ignored: (path) => {
+                // Always ignore node_modules
+                if (path.includes('node_modules')) return true;
+                if (path.includes('.git')) return true;
+                if (path.includes('.next')) return true;
+                if (path.includes('dist')) return true;
+                if (path.includes('build')) return true;
+                if (path.includes('.rigstate')) return true;
+                if (path.includes('coverage')) return true;
+                return false;
+            },
+            persistent: true,
+            ignoreInitial: true,
+            depth: 15,
+            awaitWriteFinish: {
+                stabilityThreshold: 200,
+                pollInterval: 100
+            },
+            usePolling: false, // Use native events when possible
+            interval: 300,
+            binaryInterval: 1000
+        });
+
+        watcher.on('change', (filePath: string) => {
+            if (isCodeFile(filePath)) {
+                emitter.emit('change', path.relative(process.cwd(), filePath));
+            }
+        });
+
+        watcher.on('add', (filePath: string) => {
+            if (isCodeFile(filePath)) {
+                emitter.emit('add', path.relative(process.cwd(), filePath));
+            }
+        });
+
+        watcher.on('unlink', (filePath: string) => {
+            if (isCodeFile(filePath)) {
+                emitter.emit('unlink', path.relative(process.cwd(), filePath));
+            }
+        });
+
+        watcher.on('error', (error: any) => {
+            emitter.emit('error', error);
+        });
+
+        watcher.on('ready', () => {
+            emitter.emit('ready');
+        });
+    };
+
+    emitter.stop = async () => {
+        if (watcher) {
+            await watcher.close();
+            watcher = null;
+        }
+    };
+
+    return emitter;
+}