@rigstate/cli 0.6.0

package/src/commands/env.ts

@@ -0,0 +1,158 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs/promises';
+import path from 'path';
+import { getApiKey, getProjectId, getApiUrl } from '../utils/config.js';
+import axios from 'axios';
+
+export function createEnvPullCommand() {
+    const envPull = new Command('env');
+
+    envPull
+        .command('pull')
+        .description('Pull environment variables from project vault')
+        .action(async () => {
+            console.log('');
+            console.log(chalk.bold.yellow('╔══════════════════════════════════════════╗'));
+            console.log(chalk.bold.yellow('║') + chalk.bold.white('  🛡️  RIGSTATE SOVEREIGN VAULT SYNC  🛡️   ') + chalk.bold.yellow('║'));
+            console.log(chalk.bold.yellow('╚══════════════════════════════════════════╝'));
+            console.log('');
+
+            const spinner = ora('Authenticating with Vault...').start();
+
+            // Get config
+            let apiKey: string;
+            let projectId: string | undefined;
+
+            try {
+                apiKey = getApiKey();
+            } catch (e) {
+                spinner.fail(chalk.red('Not authenticated. Run "rigstate login" first.'));
+                return;
+            }
+            spinner.succeed('Authenticated');
+
+            // Get project context
+            spinner.start('Reading project configuration...');
+            projectId = getProjectId();
+
+            if (!projectId) {
+                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) {
+                spinner.fail(chalk.red('No project context. Run "rigstate link" first.'));
+                return;
+            }
+
+            spinner.succeed(`Project: ${chalk.cyan(projectId.substring(0, 8))}...`);
+
+            const apiUrl = getApiUrl();
+
+            // Fetch secrets from Vault API
+            spinner.start('Fetching secrets from Vault...');
+
+            try {
+                const response = await axios.post(`${apiUrl}/api/v1/vault/sync`, {
+                    project_id: projectId
+                }, {
+                    headers: { Authorization: `Bearer ${apiKey}` }
+                });
+
+                if (!response.data.success) {
+                    throw new Error(response.data.error || 'Failed to fetch secrets');
+                }
+
+                const vaultContent = response.data.data.content || '';
+                const secretCount = response.data.data.count || 0;
+
+                if (secretCount === 0) {
+                    spinner.info('No secrets found in Vault for this project.');
+                    console.log(chalk.dim('  Add secrets via the Rigstate web interface.'));
+                    return;
+                }
+
+                spinner.succeed(`Retrieved ${chalk.bold(secretCount)} secret(s)`);
+
+                // Read existing .env.local for comparison
+                const envFile = path.resolve(process.cwd(), '.env.local');
+                let existingContent = '';
+                let existingKeys: Set<string> = new Set();
+
+                try {
+                    existingContent = await fs.readFile(envFile, 'utf-8');
+                    // Parse existing keys
+                    existingContent.split('\n').forEach(line => {
+                        const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+                        if (match) existingKeys.add(match[1]);
+                    });
+                } catch (e) {
+                    // File doesn't exist
+                }
+
+                // Parse vault keys
+                const vaultKeys: Set<string> = new Set();
+                vaultContent.split('\n').forEach((line: string) => {
+                    const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+                    if (match) vaultKeys.add(match[1]);
+                });
+
+                // Calculate changes
+                let newCount = 0;
+                let updatedCount = 0;
+
+                vaultKeys.forEach(key => {
+                    if (!existingKeys.has(key)) {
+                        newCount++;
+                    } else {
+                        updatedCount++;
+                    }
+                });
+
+                const unchangedCount = existingKeys.size - updatedCount;
+
+                // Write new .env.local
+                spinner.start('Writing .env.local...');
+
+                const header = [
+                    '# ==========================================',
+                    '# RIGSTATE SOVEREIGN FOUNDATION',
+                    '# Authenticated Environment Configuration',
+                    `# Synced at: ${new Date().toISOString()}`,
+                    `# Project: ${projectId}`,
+                    '# ==========================================',
+                    ''
+                ].join('\n');
+
+                await fs.writeFile(envFile, header + vaultContent + '\n');
+                spinner.succeed('Written to .env.local');
+
+                // Summary
+                console.log('');
+                console.log(chalk.bold.green('✅ Environment synchronized successfully'));
+                console.log('');
+                console.log(chalk.dim('   Summary:'));
+                console.log(chalk.green(`   + ${newCount} new`));
+                console.log(chalk.yellow(`   ~ ${updatedCount} updated`));
+                console.log(chalk.dim(`   = ${unchangedCount} unchanged`));
+                console.log('');
+
+                // Security reminder
+                console.log(chalk.bold.yellow('⚠️  Security Reminder:'));
+                console.log(chalk.dim('   - Never commit .env.local to version control.'));
+                console.log(chalk.dim('   - Ensure .gitignore includes .env.local'));
+                console.log('');
+
+            } catch (e: any) {
+                spinner.fail(chalk.red(`Failed to fetch secrets: ${e.message}`));
+            }
+        });
+
+    return envPull;
+}

package/src/commands/fix.ts

@@ -0,0 +1,140 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import axios from 'axios';
+import { glob } from 'glob';
+import fs from 'fs/promises';
+import path from 'path';
+import inquirer from 'inquirer';
+import * as Diff from 'diff';
+import { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+import { readGitignore, shouldIgnore, isCodeFile } from '../utils/files.js';
+
+export function createFixCommand(): Command {
+    return new Command('fix')
+        .description('Scan and interactively FIX detected issues using Rigstate AI')
+        .argument('[path]', 'Directory or file to scan', '.')
+        .option('--project <id>', 'Project ID to context-aware audit')
+        .action(async (targetPath: string, options: { project?: string }) => {
+            const spinner = ora();
+
+            try {
+                const apiKey = getApiKey();
+                const apiUrl = getApiUrl();
+                const projectId = options.project || getProjectId();
+
+                if (!projectId) {
+                    console.log(chalk.yellow('⚠️  Project ID is required for fixing. Using default or pass --project <id>'));
+                    // We can proceed without it, but fix quality drops. Let's warn.
+                }
+
+                const scanPath = path.resolve(process.cwd(), targetPath);
+
+                // --- Reuse Scan Logic (Simplified) ---
+                const gitignorePatterns = await readGitignore(scanPath);
+                const pattern = path.join(scanPath, '**/*');
+                const allFiles = await glob(pattern, { nodir: true, dot: false, ignore: ['**/node_modules/**', '**/.git/**'] });
+                const codeFiles = allFiles.filter(file => {
+                    const relativePath = path.relative(scanPath, file);
+                    return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
+                });
+
+                if (codeFiles.length === 0) {
+                    console.log(chalk.yellow('No code files found.'));
+                    return;
+                }
+
+                console.log(chalk.bold(`\n🧠 Rigstate Fix Mode`));
+                console.log(chalk.dim(`Scanning ${codeFiles.length} files with Project Context...\n`));
+
+                let fixedCount = 0;
+
+                for (let i = 0; i < codeFiles.length; i++) {
+                    const filePath = codeFiles[i];
+                    const relativePath = path.relative(scanPath, filePath);
+
+                    spinner.start(`Analyzing ${relativePath}...`);
+
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        const response = await axios.post(
+                            `${apiUrl}/api/v1/audit`,
+                            { content, file_path: relativePath, project_id: projectId },
+                            { headers: { 'Authorization': `Bearer ${apiKey}` }, timeout: 120000 }
+                        );
+
+                        const vulnerabilities = response.data.vulnerabilities || [];
+                        const fixableIssues = vulnerabilities.filter((v: any) => v.fixed_content);
+
+                        if (fixableIssues.length > 0) {
+                            spinner.stop();
+                            console.log(`\n${chalk.bold(relativePath)}: Found ${fixableIssues.length} fixable issues.`);
+
+                            for (const issue of fixableIssues) {
+                                console.log(chalk.red(`\n[${issue.type}] ${issue.title}`));
+                                console.log(chalk.dim(issue.suggestion || issue.message));
+
+                                // Show Diff
+                                const diff = Diff.createTwoFilesPatch(relativePath, relativePath, content, issue.fixed_content, 'Current', 'Fixed');
+                                console.log('\n' + diff.split('\n').slice(0, 15).join('\n') + (diff.split('\n').length > 15 ? '\n...' : ''));
+
+                                const { apply } = await inquirer.prompt([{
+                                    type: 'confirm',
+                                    name: 'apply',
+                                    message: `Apply this fix to ${chalk.cyan(relativePath)}?`,
+                                    default: true
+                                }]);
+
+                                if (apply) {
+                                    await fs.writeFile(filePath, issue.fixed_content);
+                                    console.log(chalk.green(`✅ Fixed applied!`));
+                                    fixedCount++;
+
+                                    if (issue.related_step_id) {
+                                        const { completeStep } = await inquirer.prompt([{
+                                            type: 'confirm',
+                                            name: 'completeStep',
+                                            message: `Frank thinks this fix completes a Roadmap Step. Mark as COMPLETED in Rigstate?`,
+                                            default: true
+                                        }]);
+
+                                        if (completeStep) {
+                                            try {
+                                                await axios.post(
+                                                    `${apiUrl}/api/v1/roadmap/update-status`,
+                                                    { step_id: issue.related_step_id, status: 'COMPLETED', project_id: projectId },
+                                                    { headers: { 'Authorization': `Bearer ${apiKey}` } }
+                                                );
+                                                console.log(chalk.green(`🚀 Roadmap updated! Mission Control is in sync.`));
+                                            } catch (err: any) {
+                                                console.error(chalk.yellow(`Failed to update roadmap: ${err.message}`));
+                                            }
+                                        }
+                                    }
+
+                                    // Stop processing this file as content changed
+                                    break;
+                                } else {
+                                    console.log(chalk.dim('Skipped.'));
+                                }
+                            }
+                        } else {
+                            spinner.text = `Checked ${relativePath} (No auto-fixes)`;
+                        }
+
+                    } catch (e: any) {
+                        // silent fail for file read/network errors in fix mode to keep flow
+                    }
+                }
+
+                spinner.stop();
+                console.log(chalk.bold.green(`\n\n🚀 Fix session complete!`));
+                console.log(`Frank fixed ${fixedCount} detected issues.`);
+                console.log(chalk.dim(`Run 'rigstate scan' to verify remaining issues.`));
+
+            } catch (error: any) {
+                spinner.fail('Fix session failed');
+                console.error(error.message);
+            }
+        });
+}

package/src/commands/focus.ts

@@ -0,0 +1,134 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getApiKey, getProjectId, getApiUrl } from '../utils/config.js';
+import axios from 'axios';
+import { execSync } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+
+export function createFocusCommand() {
+    const focus = new Command('focus');
+
+    focus
+        .alias('task')
+        .description('Get the next active roadmap task and copy its prompt to clipboard')
+        .option('--no-copy', 'Do not copy to clipboard')
+        .action(async (options) => {
+            const spinner = ora('Fetching next objective...').start();
+
+            // Get config
+            let apiKey: string;
+            let projectId: string | undefined;
+
+            try {
+                apiKey = getApiKey();
+            } catch (e) {
+                spinner.fail(chalk.red('Not authenticated. Run "rigstate login" first.'));
+                return;
+            }
+
+            projectId = getProjectId();
+            if (!projectId) {
+                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) {
+                spinner.fail(chalk.red('No project context. Run "rigstate link" first.'));
+                return;
+            }
+
+            const apiUrl = getApiUrl();
+
+            try {
+                // Fetch roadmap
+                const response = await axios.get(`${apiUrl}/api/v1/roadmap`, {
+                    params: { project_id: projectId },
+                    headers: { Authorization: `Bearer ${apiKey}` }
+                });
+
+                if (!response.data.success) {
+                    throw new Error(response.data.error || 'Failed to fetch roadmap');
+                }
+
+                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);
+                    });
+
+                if (activeTasks.length === 0) {
+                    spinner.succeed('All caught up! No active tasks found.');
+                    return;
+                }
+
+                const nextTask = activeTasks[0];
+                spinner.stop();
+
+                // Display
+                console.log('');
+                console.log(chalk.bold.blue(`📌 Task #${nextTask.step_number || '?'}: ${nextTask.title}`));
+
+                const statusColor = nextTask.status === 'IN_PROGRESS' ? chalk.yellow :
+                    nextTask.status === 'ACTIVE' ? chalk.green : chalk.dim;
+
+                console.log(chalk.dim('Status: ') + statusColor(nextTask.status));
+                console.log(chalk.dim('─'.repeat(60)));
+
+                if (nextTask.prompt_content) {
+                    console.log(chalk.white(nextTask.prompt_content));
+                    console.log(chalk.dim('─'.repeat(60)));
+
+                    // Auto-copy for Mac
+                    if (options.copy !== false) {
+                        try {
+                            if (process.platform === 'darwin') {
+                                execSync('pbcopy', { input: nextTask.prompt_content });
+                                console.log(chalk.green('✅ Prompt copied to clipboard! Ready to paste (Cmd+V).'));
+                            } else if (process.platform === 'linux') {
+                                try {
+                                    execSync('xclip -selection clipboard', { input: nextTask.prompt_content });
+                                    console.log(chalk.green('✅ Prompt copied to clipboard!'));
+                                } catch (e) {
+                                    console.log(chalk.yellow('ℹ️  Copy prompt manually (xclip not available)'));
+                                }
+                            } else {
+                                console.log(chalk.yellow('ℹ️  Copy prompt manually (Auto-copy not supported on this OS)'));
+                            }
+                        } catch (e) {
+                            // ignore copy error
+                        }
+                    }
+                } else {
+                    console.log(chalk.yellow('No prompt instructions available.'));
+                    if (nextTask.architectural_brief) {
+                        console.log(chalk.bold('Brief:'));
+                        console.log(nextTask.architectural_brief);
+                    }
+                }
+                console.log('');
+
+            } catch (e: any) {
+                spinner.fail(chalk.red(`Failed to fetch task: ${e.message}`));
+            }
+        });
+
+    return focus;
+}

package/src/commands/hooks.ts

@@ -0,0 +1,163 @@
+/**
+ * rigstate hooks - Manage git hooks for Guardian integration
+ * 
+ * Usage:
+ *   rigstate hooks install    # Install pre-commit hook
+ *   rigstate hooks uninstall  # Remove pre-commit hook
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+
+const PRE_COMMIT_SCRIPT = `#!/bin/sh
+# Rigstate Guardian Pre-commit Hook
+# Installed by: rigstate hooks install
+
+# 1. Silent Sentinel Check (Phase 5)
+if [ -f .rigstate/guardian.lock ]; then
+    echo "🛑 INTERVENTION ACTIVE: Commit blocked by Silent Sentinel."
+    echo "   A critical violation ('HARD_LOCK') was detected by the Guardian Daemon."
+    echo "   Please fix the violation to unlock the repo."
+    echo ""
+    if grep -q "HARD_LOCK_ACTIVE" .rigstate/guardian.lock; then
+        cat .rigstate/guardian.lock
+    fi
+    exit 1
+fi
+
+echo "🛡️  Running Guardian checks..."
+
+# Run check with strict mode for critical violations
+rigstate check --staged --strict=critical
+
+# Exit with the same code as rigstate check
+exit $?
+`;
+
+export function createHooksCommand(): Command {
+    const hooks = new Command('hooks')
+        .description('Manage git hooks for Guardian integration');
+
+    hooks
+        .command('install')
+        .description('Install pre-commit hook to run Guardian checks')
+        .option('--strict [level]', 'Strict level: "all" or "critical" (default)', 'critical')
+        .action(async (options: { strict: string }) => {
+            try {
+                // 1. Find .git directory
+                const gitDir = path.join(process.cwd(), '.git');
+                try {
+                    await fs.access(gitDir);
+                } catch {
+                    console.log(chalk.red('❌ Not a git repository.'));
+                    console.log(chalk.dim('   Initialize with "git init" first.'));
+                    process.exit(1);
+                }
+
+                // 2. Ensure hooks directory exists
+                const hooksDir = path.join(gitDir, 'hooks');
+                await fs.mkdir(hooksDir, { recursive: true });
+
+                // 3. Check for existing pre-commit
+                const preCommitPath = path.join(hooksDir, 'pre-commit');
+                let existingContent = '';
+                try {
+                    existingContent = await fs.readFile(preCommitPath, 'utf-8');
+                    if (existingContent.includes('rigstate')) {
+                        console.log(chalk.yellow('⚠ Rigstate pre-commit hook already installed.'));
+                        console.log(chalk.dim('   Use "rigstate hooks uninstall" to remove first.'));
+                        return;
+                    }
+                } catch {
+                    // File doesn't exist, that's fine
+                }
+
+                // 4. Create hook script with configurable strict level
+                let script = PRE_COMMIT_SCRIPT;
+                if (options.strict === 'all') {
+                    script = script.replace('--strict=critical', '--strict');
+                }
+
+                // 5. If existing hook, append to it
+                if (existingContent && !existingContent.includes('rigstate')) {
+                    // Append our hook to existing
+                    const combinedScript = existingContent + '\n\n' + script.replace('#!/bin/sh\n', '');
+                    await fs.writeFile(preCommitPath, combinedScript, { mode: 0o755 });
+                    console.log(chalk.green('✅ Rigstate hook appended to existing pre-commit.'));
+                } else {
+                    // Create new hook
+                    await fs.writeFile(preCommitPath, script, { mode: 0o755 });
+                    console.log(chalk.green('✅ Pre-commit hook installed!'));
+                }
+
+                console.log(chalk.dim(`   Path: ${preCommitPath}`));
+                console.log(chalk.dim(`   Strict level: ${options.strict}`));
+                console.log('');
+                console.log(chalk.cyan('Guardian will now check your code before each commit.'));
+                console.log(chalk.dim('Use "rigstate hooks uninstall" to remove the hook.'));
+
+            } catch (error: any) {
+                console.error(chalk.red('Failed to install hook:'), error.message);
+                process.exit(1);
+            }
+        });
+
+    hooks
+        .command('uninstall')
+        .description('Remove Rigstate pre-commit hook')
+        .action(async () => {
+            try {
+                const preCommitPath = path.join(process.cwd(), '.git', 'hooks', 'pre-commit');
+
+                try {
+                    const content = await fs.readFile(preCommitPath, 'utf-8');
+
+                    if (!content.includes('rigstate')) {
+                        console.log(chalk.yellow('⚠ No Rigstate hook found in pre-commit.'));
+                        return;
+                    }
+
+                    // Check if it's our hook exclusively
+                    if (content.includes('# Rigstate Guardian Pre-commit Hook') &&
+                        content.trim().split('\n').filter(l => l && !l.startsWith('#')).length <= 4) {
+                        // It's only our hook, remove the file
+                        await fs.unlink(preCommitPath);
+                        console.log(chalk.green('✅ Pre-commit hook removed.'));
+                    } else {
+                        // There's other content, just remove our section
+                        const lines = content.split('\n');
+                        const filteredLines = [];
+                        let inRigstateSection = false;
+
+                        for (const line of lines) {
+                            if (line.includes('Rigstate Guardian Pre-commit Hook')) {
+                                inRigstateSection = true;
+                                continue;
+                            }
+                            if (inRigstateSection && line.includes('exit $?')) {
+                                inRigstateSection = false;
+                                continue;
+                            }
+                            if (!inRigstateSection && !line.includes('rigstate check')) {
+                                filteredLines.push(line);
+                            }
+                        }
+
+                        await fs.writeFile(preCommitPath, filteredLines.join('\n'), { mode: 0o755 });
+                        console.log(chalk.green('✅ Rigstate section removed from pre-commit hook.'));
+                    }
+
+                } catch {
+                    console.log(chalk.yellow('⚠ No pre-commit hook found.'));
+                }
+
+            } catch (error: any) {
+                console.error(chalk.red('Failed to uninstall hook:'), error.message);
+                process.exit(1);
+            }
+        });
+
+    return hooks;
+}