@rigstate/cli 0.6.0

package/src/commands/sync.ts

@@ -0,0 +1,339 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getApiKey, getProjectId, getApiUrl, setProjectId } from '../utils/config.js';
+import axios from 'axios';
+import fs from 'fs/promises';
+import path from 'path';
+
+export function createSyncCommand() {
+    const sync = new Command('sync');
+
+    sync
+        .description('Synchronize local state with Rigstate Cloud')
+        .option('-p, --project <id>', 'Specify Project ID (saves to config automatically)')
+        .action(async (options) => {
+            const spinner = ora('Synchronizing project state...').start();
+
+            try {
+                // 1. Authentication Check
+                let apiKey;
+                try {
+                    apiKey = getApiKey();
+                } catch (e) {
+                    spinner.fail('Not authenticated. Run "rigstate login" first.');
+                    return;
+                }
+
+                // 2. Project Context Resolution
+                let projectId = options.project;
+
+                // Check local .rigstate manifest
+                if (!projectId) {
+                    try {
+                        const manifestPath = path.join(process.cwd(), '.rigstate');
+                        const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+                        const manifest = JSON.parse(manifestContent);
+                        if (manifest.project_id) projectId = manifest.project_id;
+                    } catch (e) { }
+                }
+
+                // Check global config
+                if (!projectId) projectId = getProjectId();
+
+                if (options.project) {
+                    // Persistence: Save project ID for future use
+                    setProjectId(options.project);
+                }
+
+                if (!projectId) {
+                    spinner.fail('No project context found.\n Run with --project <id> once to save context.');
+                    return;
+                }
+
+                const apiUrl = getApiUrl();
+
+                // 3. API Execution
+                const response = await axios.get(`${apiUrl}/api/v1/roadmap`, {
+                    params: { project_id: projectId },
+                    headers: { Authorization: `Bearer ${apiKey}` }
+                });
+
+                // Parse Standardized Response ({ success, data, ... })
+                if (!response.data.success) {
+                    throw new Error(response.data.error || 'Unknown API failure');
+                }
+
+                const { roadmap, project } = response.data.data;
+                const timestamp = response.data.timestamp;
+
+                // 4. Write Artifacts
+                const targetPath = path.join(process.cwd(), 'roadmap.json');
+                const fileContent = JSON.stringify({
+                    project,
+                    last_synced: timestamp,
+                    roadmap
+                }, null, 2);
+
+                await fs.writeFile(targetPath, fileContent, 'utf-8');
+
+                // 4b. Write Context Manifest (.rigstate) - CONTEXT GUARD
+                try {
+                    const manifestPath = path.join(process.cwd(), '.rigstate');
+                    const manifestContent = {
+                        project_id: projectId,
+                        project_name: project,
+                        last_synced: timestamp,
+                        api_url: apiUrl
+                    };
+                    await fs.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), 'utf-8');
+                } catch (e) {
+                    // Fail silently
+                }
+
+                // 4c. Provision Agent Skills (Skills Dominion)
+                console.log(chalk.bold('\n🧠 Agent Skills Provisioning...'));
+                try {
+                    const { provisionSkills, generateSkillsDiscoveryBlock } = await import('../utils/skills-provisioner.js');
+                    const skills = await provisionSkills(apiUrl, apiKey, projectId, process.cwd());
+
+                    // Update .cursorrules with skills discovery block (if file exists)
+                    const cursorRulesPath = path.join(process.cwd(), '.cursorrules');
+                    try {
+                        let rulesContent = await fs.readFile(cursorRulesPath, 'utf-8');
+                        const skillsBlock = generateSkillsDiscoveryBlock(skills);
+
+                        // Replace existing skills block or insert after PROJECT CONTEXT
+                        if (rulesContent.includes('<available_skills>')) {
+                            rulesContent = rulesContent.replace(
+                                /<available_skills>[\s\S]*?<\/available_skills>/,
+                                skillsBlock
+                            );
+                        } else if (rulesContent.includes('## 🧠 PROJECT CONTEXT')) {
+                            // Insert after PROJECT CONTEXT section
+                            const insertPoint = rulesContent.indexOf('---', rulesContent.indexOf('## 🧠 PROJECT CONTEXT'));
+                            if (insertPoint !== -1) {
+                                rulesContent = rulesContent.slice(0, insertPoint + 3) +
+                                    '\n\n' + skillsBlock + '\n' +
+                                    rulesContent.slice(insertPoint + 3);
+                            }
+                        }
+
+                        await fs.writeFile(cursorRulesPath, rulesContent, 'utf-8');
+                        console.log(chalk.dim(`  Updated .cursorrules with skills discovery block`));
+                    } catch (e) {
+                        // .cursorrules doesn't exist or couldn't be updated
+                    }
+                } catch (e: any) {
+                    console.log(chalk.yellow(`  ⚠ Skills provisioning skipped: ${e.message}`));
+                }
+
+                // 5. Process Execution Logs (MISSION REPORTING)
+                try {
+                    const logPath = path.join(process.cwd(), '.rigstate', 'logs', 'last_execution.json');
+                    try {
+                        const logContent = await fs.readFile(logPath, 'utf-8');
+                        const logData = JSON.parse(logContent);
+
+                        if (logData.task_summary) {
+                            await axios.post(`${apiUrl}/api/v1/execution-logs`, {
+                                project_id: projectId,
+                                ...logData,
+                                agent_role: process.env.RIGSTATE_MODE === 'SUPERVISOR' ? 'SUPERVISOR' : 'WORKER'
+                            }, {
+                                headers: { Authorization: `Bearer ${apiKey}` }
+                            });
+
+                            await fs.unlink(logPath);
+                            console.log(chalk.dim(`✔ Mission Report uploaded.`));
+                        }
+                    } catch (e: any) {
+                        // Ignore ENOENT (file not found), log errors if API fails
+                        if (e.code !== 'ENOENT') {
+                            // console.log(chalk.yellow('Log upload skipped: ' + e.message));
+                        }
+                    }
+                } catch (e) { }
+
+                // 6. User Feedback
+                spinner.succeed(chalk.green(`Synced ${roadmap.length} roadmap steps for project "${project}"`));
+                console.log(chalk.dim(`Local files updated: roadmap.json`));
+
+                const { runGuardianWatchdog } = await import('../utils/watchdog.js');
+                const settings = response.data.data.settings || {};
+                await runGuardianWatchdog(process.cwd(), settings, projectId);
+
+                // 8. Bridge Heartbeat & Pending Tasks
+                console.log(chalk.bold('\n📡 Agent Bridge Heartbeat...'));
+                try {
+                    const bridgeResponse = await axios.get(`${apiUrl}/api/v1/agent/bridge`, {
+                        params: { project_id: projectId },
+                        headers: { Authorization: `Bearer ${apiKey}` }
+                    });
+
+                    if (bridgeResponse.data.success) {
+                        const tasks = bridgeResponse.data.tasks;
+                        const pending = tasks.filter((t: any) => t.status === 'PENDING');
+                        const approved = tasks.filter((t: any) => t.status === 'APPROVED');
+
+                        if (pending.length > 0 || approved.length > 0) {
+                            console.log(chalk.yellow(`⚠ Bridge Alert: ${pending.length} pending, ${approved.length} approved tasks found.`));
+                            console.log(chalk.dim('Run "rigstate fix" to process these tasks or ensure your IDE MCP server is active.'));
+                        } else {
+                            console.log(chalk.green('✔ Heartbeat healthy. No pending bridge tasks.'));
+                        }
+
+                        // Acknowledge Pings if any
+                        const pings = pending.filter((t: any) => t.proposal?.startsWith('ping'));
+                        for (const ping of pings) {
+                            await axios.post(`${apiUrl}/api/v1/agent/bridge`, {
+                                bridge_id: ping.id,
+                                status: 'COMPLETED',
+                                summary: 'Pong! CLI Sync Heartbeat confirmed.'
+                            }, {
+                                headers: { Authorization: `Bearer ${apiKey}` }
+                            });
+                            console.log(chalk.cyan(`🏓 Pong! Acknowledged heartbeat signal [${ping.id}]`));
+                        }
+                    }
+                } catch (e: any) {
+                    console.log(chalk.yellow(`⚠ Could not verify Bridge status: ${e.message}`));
+                }
+
+                if (options.project) {
+                    console.log(chalk.blue(`Project context saved. Future commands will use this project.`));
+                }
+
+                // 9. Migration Guard (The Firewall)
+                try {
+                    const migrationDir = path.join(process.cwd(), 'supabase', 'migrations');
+                    const files = await fs.readdir(migrationDir);
+                    const sqlFiles = files.filter(f => f.endsWith('.sql')).sort();
+
+                    if (sqlFiles.length > 0) {
+                        const latestMigration = sqlFiles[sqlFiles.length - 1];
+                        console.log(chalk.dim(`\n🛡  Migration Guard:`));
+                        console.log(chalk.dim(`   Latest Local: ${latestMigration}`));
+                        console.log(chalk.yellow(`   ⚠  Ensure DB schema matches this version. CLI cannot verify Remote RLS policies directly.`));
+                    }
+                } catch (e) {
+                    // No migrations folder, or error reading - ignore
+                }
+
+                // 10. Sovereign Foundation (Vault Sync)
+                try {
+                    const vaultResponse = await axios.post(`${apiUrl}/api/v1/vault/sync`,
+                        { project_id: projectId },
+                        { headers: { Authorization: `Bearer ${apiKey}` } }
+                    );
+
+                    if (vaultResponse.data.success) {
+                        const vaultContent: string = vaultResponse.data.data.content || '';
+                        const localEnvPath = path.join(process.cwd(), '.env.local');
+                        let localContent = '';
+
+                        try {
+                            localContent = await fs.readFile(localEnvPath, 'utf-8');
+                        } catch (e) { /* File doesn't exist */ }
+
+                        // Normalize for comparison (trim, ignore comments?) - Simple trim for now
+                        if (vaultContent.trim() !== localContent.trim()) {
+                            console.log(chalk.bold('\n🔐 Sovereign Foundation (Vault):'));
+                            console.log(chalk.yellow('   Status: Drift Detected / Update Available'));
+
+                            const { syncVault } = await import('inquirer').then(m => m.default.prompt([{
+                                type: 'confirm',
+                                name: 'syncVault',
+                                message: 'Synchronize local .env.local with Vault secrets?',
+                                default: false
+                            }]));
+
+                            if (syncVault) {
+                                await fs.writeFile(localEnvPath, vaultContent, 'utf-8');
+                                console.log(chalk.green('   ✅ .env.local synchronized with Vault.'));
+                            } else {
+                                console.log(chalk.dim('   Skipped vault sync.'));
+                            }
+                        } else {
+                            console.log(chalk.dim('\n🔐 Sovereign Foundation: Synced.'));
+                        }
+                    }
+                } catch (e: any) {
+                    // Fail silently or warn if vault access denied (expected for some users)
+                    // console.log(chalk.dim(`   (Vault check skipped: ${e.message})`));
+                }
+
+                // 11. System Integrity Checks (The Firewall)
+                console.log(chalk.dim('\n🛡️ System Integrity Check...'));
+                await checkSystemIntegrity(apiUrl, apiKey, projectId);
+
+            } catch (error: any) {
+                if (axios.isAxiosError(error)) {
+                    const message = error.response?.data?.error || error.message;
+                    spinner.fail(chalk.red(`Sync failed: ${message}`));
+                } else {
+                    spinner.fail(chalk.red('Sync failed: ' + (error.message || 'Unknown error')));
+                }
+            }
+        });
+
+    return sync;
+}
+
+/**
+ * System Integrity Checks
+ * Verifies Migration Sync and RLS Status via API
+ */
+async function checkSystemIntegrity(apiUrl: string, apiKey: string, projectId: string) {
+    try {
+        // Call System Integrity API
+        const response = await axios.get(`${apiUrl}/api/v1/system/integrity`, {
+            params: { project_id: projectId },
+            headers: { Authorization: `Bearer ${apiKey}` }
+        });
+
+        if (response.data.success) {
+            const { migrations, rls, guardian_violations } = response.data.data;
+
+            // Migration Status
+            if (migrations) {
+                if (migrations.in_sync) {
+                    console.log(chalk.green(`   ✅ Migrations synced (${migrations.count} versions)`));
+                } else {
+                    console.log(chalk.red(`   🛑 CRITICAL: DB Schema out of sync! ${migrations.missing?.length || 0} migrations not applied.`));
+                    if (migrations.missing?.length > 0) {
+                        console.log(chalk.dim(`      Missing: ${migrations.missing.slice(0, 3).join(', ')}${migrations.missing.length > 3 ? '...' : ''}`));
+                    }
+                    console.log(chalk.yellow(`      Run 'supabase db push' or apply migrations immediately.`));
+                }
+            }
+
+            // RLS Status
+            if (rls) {
+                if (rls.all_secured) {
+                    console.log(chalk.green(`   ✅ RLS Audit Passed (${rls.table_count} tables secured)`));
+                } else {
+                    console.log(chalk.red(`   🛑 CRITICAL: Security Vulnerability! ${rls.unsecured?.length || 0} tables have RLS disabled.`));
+                    rls.unsecured?.forEach((table: string) => {
+                        console.log(chalk.red(`      - ${table}`));
+                    });
+                    console.log(chalk.yellow('      Enable RLS immediately: ALTER TABLE "table" ENABLE ROW LEVEL SECURITY;'));
+                }
+            }
+
+            // Guardian Violations
+            if (guardian_violations) {
+                if (guardian_violations.count === 0) {
+                    console.log(chalk.green('   ✅ Guardian: No active violations'));
+                } else {
+                    console.log(chalk.yellow(`   ⚠️ Guardian: ${guardian_violations.count} active violations`));
+                    console.log(chalk.dim('      Run "rigstate check" for details.'));
+                }
+            }
+        }
+    } catch (e: any) {
+        // API might not have this endpoint yet - fail silently
+        console.log(chalk.dim('   (System integrity check skipped - API endpoint not available)'));
+    }
+}
+

package/src/commands/watch.ts

@@ -0,0 +1,283 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import chokidar from 'chokidar';
+import fs from 'fs/promises';
+import path from 'path';
+import { execSync } from 'child_process';
+import { getApiKey, getProjectId, getApiUrl } from '../utils/config.js';
+import axios from 'axios';
+
+interface VerificationCriteria {
+    type: 'file_exists' | 'file_content' | 'content_match';
+    path: string;
+    pattern?: string;
+    match?: string;
+}
+
+export function createWatchCommand() {
+    const watch = new Command('watch');
+
+    watch
+        .description('Watch for changes and auto-verify roadmap tasks')
+        .option('--no-auto-commit', 'Disable auto-commit on verification')
+        .option('--no-auto-push', 'Disable auto-push after commit')
+        .option('--run-tests', 'Run tests before committing')
+        .option('--test-command <cmd>', 'Custom test command (default: npm test)')
+        .action(async (options) => {
+            console.log(chalk.bold.blue('🔭 Rigstate Watch Mode'));
+            console.log(chalk.dim('Monitoring for task completion...'));
+            console.log('');
+
+            // Get config
+            let apiKey: string;
+            let projectId: string | undefined;
+
+            try {
+                apiKey = getApiKey();
+            } catch (e) {
+                console.log(chalk.red('Not authenticated. Run "rigstate login" first.'));
+                return;
+            }
+
+            projectId = getProjectId();
+            if (!projectId) {
+                // Try to read from local manifest
+                try {
+                    const manifestPath = path.join(process.cwd(), '.rigstate');
+                    const content = await fs.readFile(manifestPath, 'utf-8');
+                    const manifest = JSON.parse(content);
+                    projectId = manifest.project_id;
+                } catch (e) { }
+            }
+
+            if (!projectId) {
+                console.log(chalk.red('No project context. Run "rigstate link" or "rigstate sync --project <id>" first.'));
+                return;
+            }
+
+            const apiUrl = getApiUrl();
+
+            // Settings
+            const config = {
+                autoCommit: options.autoCommit !== false,
+                autoPush: options.autoPush !== false,
+                runTests: options.runTests || false,
+                testCommand: options.testCommand || 'npm test'
+            };
+
+            console.log(chalk.dim(`Auto-commit: ${config.autoCommit ? 'ON' : 'OFF'}`));
+            console.log(chalk.dim(`Auto-push: ${config.autoPush ? 'ON' : 'OFF'}`));
+            console.log('');
+
+            // Fetch active task
+            const fetchActiveTask = async () => {
+                try {
+                    const response = await axios.get(`${apiUrl}/api/v1/roadmap`, {
+                        params: { project_id: projectId },
+                        headers: { Authorization: `Bearer ${apiKey}` }
+                    });
+
+                    if (!response.data.success) return null;
+
+                    const roadmap = response.data.data.roadmap || [];
+
+                    // Priority: IN_PROGRESS > ACTIVE > LOCKED
+                    const statusPriority: Record<string, number> = {
+                        'IN_PROGRESS': 0,
+                        'ACTIVE': 1,
+                        'LOCKED': 2
+                    };
+
+                    const activeTasks = roadmap
+                        .filter((t: any) => ['IN_PROGRESS', 'ACTIVE', 'LOCKED'].includes(t.status))
+                        .sort((a: any, b: any) => {
+                            const pA = statusPriority[a.status] ?? 99;
+                            const pB = statusPriority[b.status] ?? 99;
+                            if (pA !== pB) return pA - pB;
+                            return (a.step_number || 0) - (b.step_number || 0);
+                        });
+
+                    return activeTasks[0] || null;
+                } catch (e) {
+                    return null;
+                }
+            };
+
+            // Check verification criteria
+            const checkCriteria = async (criteria: VerificationCriteria): Promise<boolean> => {
+                try {
+                    const fullPath = path.resolve(process.cwd(), criteria.path);
+
+                    switch (criteria.type) {
+                        case 'file_exists':
+                            await fs.access(fullPath);
+                            return true;
+
+                        case 'file_content':
+                            const content = await fs.readFile(fullPath, 'utf-8');
+                            return content.length > 0;
+
+                        case 'content_match':
+                            if (!criteria.match) return false;
+                            const fileContent = await fs.readFile(fullPath, 'utf-8');
+                            return fileContent.includes(criteria.match);
+
+                        default:
+                            return false;
+                    }
+                } catch (e) {
+                    return false;
+                }
+            };
+
+            // Complete task
+            const completeTask = async (taskId: string, task: any) => {
+                const spinner = ora('Completing task...').start();
+
+                try {
+                    // Run tests if enabled
+                    if (config.runTests) {
+                        spinner.text = 'Running tests...';
+                        try {
+                            execSync(config.testCommand, { stdio: 'pipe' });
+                            spinner.text = 'Tests passed!';
+                        } catch (e) {
+                            spinner.fail('Tests failed. Task not completed.');
+                            return;
+                        }
+                    }
+
+                    // Update status via API
+                    await axios.post(`${apiUrl}/api/v1/roadmap/update-status`, {
+                        project_id: projectId,
+                        chunk_id: taskId,
+                        status: 'COMPLETED'
+                    }, {
+                        headers: { Authorization: `Bearer ${apiKey}` }
+                    });
+
+                    spinner.succeed(chalk.green(`✅ Task #${task.step_number} completed: ${task.title}`));
+
+                    // Auto-commit
+                    if (config.autoCommit) {
+                        spinner.start('Committing changes...');
+                        try {
+                            execSync('git add -A', { stdio: 'pipe' });
+                            const commitMsg = `feat: Complete task #${task.step_number} - ${task.title}`;
+                            execSync(`git commit -m "${commitMsg}"`, { stdio: 'pipe' });
+                            spinner.succeed('Changes committed');
+
+                            // Auto-push
+                            if (config.autoPush) {
+                                spinner.start('Pushing to remote...');
+                                try {
+                                    execSync('git push', { stdio: 'pipe' });
+                                    spinner.succeed('Pushed to remote');
+                                } catch (e) {
+                                    spinner.warn('Push failed (no remote or conflict)');
+                                }
+                            }
+                        } catch (e: any) {
+                            spinner.warn('Nothing to commit or commit failed');
+                        }
+                    }
+
+                    console.log('');
+                    console.log(chalk.blue('Watching for next task...'));
+
+                } catch (e: any) {
+                    spinner.fail(`Failed to complete task: ${e.message}`);
+                }
+            };
+
+            // Main watch loop
+            let currentTask: any = null;
+            let isProcessing = false;
+
+            const processActiveTask = async () => {
+                if (isProcessing) return;
+                isProcessing = true;
+
+                const task = await fetchActiveTask();
+
+                if (!task) {
+                    if (currentTask) {
+                        console.log(chalk.green('🎉 All tasks completed! Watching for new tasks...'));
+                        currentTask = null;
+                    }
+                    isProcessing = false;
+                    return;
+                }
+
+                if (!currentTask || currentTask.id !== task.id) {
+                    currentTask = task;
+                    console.log('');
+                    console.log(chalk.bold.yellow(`📌 Active Task #${task.step_number}: ${task.title}`));
+                    console.log(chalk.dim(`Status: ${task.status}`));
+
+                    if (task.verification_criteria) {
+                        console.log(chalk.dim('Verification: Auto-checking criteria...'));
+                    }
+                }
+
+                // Check verification criteria if present
+                if (task.verification_criteria && Array.isArray(task.verification_criteria)) {
+                    let allPassed = true;
+                    for (const criteria of task.verification_criteria) {
+                        const passed = await checkCriteria(criteria);
+                        if (!passed) {
+                            allPassed = false;
+                            break;
+                        }
+                    }
+
+                    if (allPassed) {
+                        console.log(chalk.green('✓ All verification criteria passed!'));
+                        await completeTask(task.id, task);
+                        currentTask = null;
+                    }
+                }
+
+                isProcessing = false;
+            };
+
+            // Initial check
+            await processActiveTask();
+
+            // Set up file watcher
+            const watcher = chokidar.watch('.', {
+                ignored: [
+                    /(^|[\/\\])\../,  // dotfiles
+                    '**/node_modules/**',
+                    '**/.git/**',
+                    '**/.next/**',
+                    '**/dist/**'
+                ],
+                persistent: true,
+                ignoreInitial: true
+            });
+
+            watcher.on('all', async (event, filePath) => {
+                if (['add', 'change', 'unlink'].includes(event)) {
+                    // Debounce - wait a bit for multiple rapid changes
+                    setTimeout(() => processActiveTask(), 500);
+                }
+            });
+
+            console.log(chalk.dim('Watching for file changes... (Ctrl+C to exit)'));
+
+            // Periodic check every 30 seconds
+            setInterval(() => processActiveTask(), 30000);
+
+            // Keep process alive
+            process.on('SIGINT', () => {
+                console.log('');
+                console.log(chalk.dim('Watch mode stopped.'));
+                watcher.close();
+                process.exit(0);
+            });
+        });
+
+    return watch;
+}