@rigstate/cli 0.6.0

package/src/commands/scan.ts

@@ -0,0 +1,242 @@
+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 { getApiKey, getApiUrl, getProjectId } from '../utils/config.js';
+import { readGitignore, shouldIgnore, isCodeFile } from '../utils/files.js';
+
+interface ScanResult {
+    id: string;
+    file_path: string;
+    issues: Array<{
+        type: string;
+        severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+        message: string;
+        line?: number;
+    }>;
+}
+
+interface ApiResponse {
+    results: ScanResult[];
+    summary: {
+        total_files: number;
+        total_issues: number;
+        by_severity: Record<string, number>;
+    };
+}
+
+export function createScanCommand(): Command {
+    return new Command('scan')
+        .description('Scan code files for security and quality issues')
+        .argument('[path]', 'Directory or file to scan', '.')
+        .option('--json', 'Output results as JSON')
+        .option('--project <id>', 'Project ID to associate with this scan')
+        .action(async (targetPath: string, options: { json?: boolean; project?: string }) => {
+            const spinner = ora();
+
+            try {
+                // Get API credentials
+                const apiKey = getApiKey();
+                const apiUrl = getApiUrl();
+                const projectId = options.project || getProjectId();
+
+                if (!projectId) {
+                    console.warn(
+                        chalk.yellow(
+                            '⚠️  No project ID specified. Use --project <id> or set a default.'
+                        )
+                    );
+                }
+
+                // Resolve target path
+                const scanPath = path.resolve(process.cwd(), targetPath);
+
+                spinner.start(`Scanning ${chalk.cyan(scanPath)}...`);
+
+                // Read .gitignore patterns
+                const gitignorePatterns = await readGitignore(scanPath);
+
+                // Find all code files
+                const pattern = path.join(scanPath, '**/*');
+                const allFiles = await glob(pattern, {
+                    nodir: true,
+                    dot: false,
+                    ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'],
+                });
+
+                // Filter files
+                const codeFiles = allFiles.filter((file) => {
+                    const relativePath = path.relative(scanPath, file);
+                    return isCodeFile(file) && !shouldIgnore(relativePath, gitignorePatterns);
+                });
+
+                if (codeFiles.length === 0) {
+                    spinner.warn(chalk.yellow('No code files found to scan.'));
+                    return;
+                }
+
+                spinner.text = `Found ${codeFiles.length} files. Scanning...`;
+
+                // Scan each file individually
+                const results: ScanResult[] = [];
+                let totalIssues = 0;
+                const severityCounts: Record<string, number> = {};
+
+                for (let i = 0; i < codeFiles.length; i++) {
+                    const filePath = codeFiles[i];
+                    const relativePath = path.relative(scanPath, filePath);
+
+                    spinner.text = `Scanning ${i + 1}/${codeFiles.length}: ${relativePath}`;
+
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+
+                        // Call the API for this file
+                        const response = await axios.post(
+                            `${apiUrl}/api/v1/audit`,
+                            {
+                                content,
+                                file_path: relativePath,
+                                project_id: projectId,
+                            },
+                            {
+                                headers: {
+                                    'Authorization': `Bearer ${apiKey}`,
+                                    'Content-Type': 'application/json',
+                                },
+                                timeout: 60000, // 1 minute per file
+                            }
+                        );
+
+                        // Aggregate results
+                        const vulnerabilities = response.data.vulnerabilities || [];
+                        if (vulnerabilities.length > 0) {
+                            results.push({
+                                id: response.data.id || relativePath,
+                                file_path: relativePath,
+                                issues: vulnerabilities.map((v: any) => ({
+                                    type: v.type,
+                                    severity: v.severity,
+                                    message: v.description || v.title,
+                                    line: v.line_number,
+                                })),
+                            });
+
+                            totalIssues += vulnerabilities.length;
+
+                            vulnerabilities.forEach((v: any) => {
+                                severityCounts[v.severity] = (severityCounts[v.severity] || 0) + 1;
+                            });
+                        }
+                    } catch (fileError) {
+                        if (axios.isAxiosError(fileError)) {
+                            console.warn(chalk.yellow(`\n⚠️  Skipping ${relativePath}: ${fileError.message}`));
+                        } else {
+                            console.warn(chalk.yellow(`\n⚠️  Error reading ${relativePath}`));
+                        }
+                    }
+                }
+
+                spinner.succeed(chalk.green('✅ Scan completed!'));
+
+                // Build aggregated response
+                const aggregatedResponse: ApiResponse = {
+                    results,
+                    summary: {
+                        total_files: codeFiles.length,
+                        total_issues: totalIssues,
+                        by_severity: severityCounts,
+                    },
+                };
+
+                // Output results
+                if (options.json) {
+                    console.log(JSON.stringify(aggregatedResponse, null, 2));
+                } else {
+                    printPrettyResults(aggregatedResponse);
+                }
+            } catch (error) {
+                spinner.fail(chalk.red('❌ Scan failed'));
+
+                if (axios.isAxiosError(error)) {
+                    if (error.response) {
+                        console.error(chalk.red('API Error:'), error.response.data);
+                    } else if (error.request) {
+                        console.error(
+                            chalk.red('Network Error:'),
+                            'Could not reach the API. Is the server running?'
+                        );
+                    } else {
+                        console.error(chalk.red('Error:'), error.message);
+                    }
+                } else {
+                    console.error(
+                        chalk.red('Error:'),
+                        error instanceof Error ? error.message : 'Unknown error'
+                    );
+                }
+
+                process.exit(1);
+            }
+        });
+}
+
+function printPrettyResults(data: ApiResponse): void {
+    const { results, summary } = data;
+
+    console.log('\n' + chalk.bold('📊 Scan Summary'));
+    console.log(chalk.dim('─'.repeat(60)));
+    console.log(`Total Files Scanned: ${chalk.cyan(summary.total_files)}`);
+    console.log(`Total Issues Found: ${chalk.yellow(summary.total_issues)}`);
+
+    if (summary.by_severity) {
+        console.log('\nIssues by Severity:');
+        Object.entries(summary.by_severity).forEach(([severity, count]) => {
+            const color = getSeverityColor(severity as any);
+            console.log(`  ${color(`${severity}:`)} ${count}`);
+        });
+    }
+
+    if (results && results.length > 0) {
+        console.log('\n' + chalk.bold('🔍 Detailed Results'));
+        console.log(chalk.dim('─'.repeat(60)));
+
+        results.forEach((result) => {
+            if (result.issues && result.issues.length > 0) {
+                console.log(`\n${chalk.bold(result.file_path)}`);
+
+                result.issues.forEach((issue) => {
+                    const severityColor = getSeverityColor(issue.severity);
+                    const lineInfo = issue.line ? chalk.dim(`:${issue.line}`) : '';
+
+                    console.log(
+                        `  ${severityColor(`[${issue.severity.toUpperCase()}]`)} ${issue.type}${lineInfo}`
+                    );
+                    console.log(`  ${chalk.dim(issue.message)}`);
+                });
+            }
+        });
+    }
+
+    console.log('\n' + chalk.dim('─'.repeat(60)));
+}
+
+function getSeverityColor(severity: string): (str: string) => string {
+    switch (severity.toLowerCase()) {
+        case 'critical':
+            return chalk.red.bold;
+        case 'high':
+            return chalk.red;
+        case 'medium':
+            return chalk.yellow;
+        case 'low':
+            return chalk.blue;
+        case 'info':
+            return chalk.gray;
+        default:
+            return chalk.white;
+    }
+}

package/src/commands/sync-rules.ts

@@ -0,0 +1,191 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getApiKey, getApiUrl } from '../utils/config.js';
+import axios from 'axios';
+
+interface SyncResult {
+    projectId: string;
+    projectName: string;
+    status: 'success' | 'failed';
+    error?: string;
+}
+
+export function createSyncRulesCommand() {
+    const syncRules = new Command('sync-rules');
+
+    syncRules
+        .description('🛡️ Push Frank Protocol v1.0 to all existing projects')
+        .option('--dry-run', 'Preview changes without pushing to GitHub')
+        .option('--project <id>', 'Sync a specific project only')
+        .action(async (options) => {
+            const spinner = ora('🛡️ Frank Protocol: Initializing retroactive sync...').start();
+            const results: SyncResult[] = [];
+
+            // Get config
+            let apiKey: string;
+            try {
+                apiKey = getApiKey();
+            } catch (e) {
+                spinner.fail(chalk.red('Not authenticated. Run "rigstate login" first.'));
+                return;
+            }
+
+            const apiUrl = getApiUrl();
+
+            try {
+                // Fetch projects via API
+                spinner.text = 'Fetching projects...';
+
+                const projectsResponse = await axios.get(`${apiUrl}/api/v1/projects`, {
+                    params: options.project ? { project_id: options.project } : {},
+                    headers: { Authorization: `Bearer ${apiKey}` }
+                });
+
+                if (!projectsResponse.data.success) {
+                    throw new Error(projectsResponse.data.error || 'Failed to fetch projects');
+                }
+
+                let projects = projectsResponse.data.data.projects || [];
+
+                if (projects.length === 0) {
+                    spinner.fail(chalk.red('No projects found.'));
+                    return;
+                }
+
+                // If multiple projects found and no specific project flag, ask user
+                if (projects.length > 1 && !options.project) {
+                    spinner.stop(); // Stop spinner to allow interaction
+
+                    const inquirer = (await import('inquirer')).default;
+                    const { selectedProjectId } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'selectedProjectId',
+                        message: 'Multiple projects found. Which one do you want to sync?',
+                        choices: projects.map((p: any) => ({
+                            name: `${p.name} [${p.id}]`,
+                            value: p.id
+                        }))
+                    }]);
+
+                    projects = projects.filter((p: any) => p.id === selectedProjectId);
+                    options.project = selectedProjectId; // Set this so we know we are in a targeted context for file writing
+
+                    // Try to save this preference to .env for future
+                    try {
+                        const fs = await import('fs/promises');
+                        const path = await import('path');
+                        const envPath = path.join(process.cwd(), '.env');
+                        const envLocalPath = path.join(process.cwd(), '.env.local');
+
+                        // Check if .env.local exists, otherwise check .env
+                        let targetEnv = envLocalPath;
+                        try {
+                            await fs.access(envLocalPath);
+                        } catch {
+                            try {
+                                await fs.access(envPath);
+                                targetEnv = envPath;
+                            } catch {
+                                // Neither exist, create .env
+                                targetEnv = envPath;
+                            }
+                        }
+
+                        let content = '';
+                        try {
+                            content = await fs.readFile(targetEnv, 'utf-8');
+                        } catch { }
+
+                        if (!content.includes('RIGSTATE_PROJECT_ID')) {
+                            const newContent = content.endsWith('\n') || content === ''
+                                ? `${content}RIGSTATE_PROJECT_ID=${selectedProjectId}\n`
+                                : `${content}\nRIGSTATE_PROJECT_ID=${selectedProjectId}\n`;
+
+                            await fs.writeFile(targetEnv, newContent, 'utf-8');
+                            console.log(chalk.dim(`   💾 Saved default project to ${path.basename(targetEnv)}`));
+                        }
+                    } catch (e) {
+                        // Ignore error saving env
+                    }
+                }
+
+                spinner.succeed(`Syncing project: ${projects[0].name}`);
+
+                // Process each project
+                for (const project of projects) {
+                    const projectSpinner = ora(`  Syncing: ${project.name}...`).start();
+
+                    try {
+                        if (options.dryRun) {
+                            projectSpinner.succeed(chalk.yellow(`  [DRY-RUN] Would sync: ${project.name}`));
+                            results.push({ projectId: project.id, projectName: project.name, status: 'success' });
+                            continue;
+                        }
+
+                        // Call API to regenerate and sync rules
+                        const syncResponse = await axios.post(`${apiUrl}/api/v1/rules/sync`, {
+                            project_id: project.id
+                        }, {
+                            headers: { Authorization: `Bearer ${apiKey}` }
+                        });
+
+                        if (syncResponse.data.success) {
+                            if (syncResponse.data.data.github_synced) {
+                                projectSpinner.succeed(chalk.green(`  ✅ ${project.name} [${project.id}] → GitHub synced`));
+                            } else {
+                                projectSpinner.info(chalk.blue(`  ℹ️ ${project.name} [${project.id}] → Rules generated (no GitHub)`));
+                            }
+
+                            // Write files locally if we are syncing a single project or if inferred context matches
+                            // For safety, if user didn't specify project and we found multiple, we only write if we can be sure.
+                            // But usually, if you run this in a repo, you want the files. 
+                            // Let's write files if they are returned and we are arguably in the right place.
+                            // To be safe: Only write if projects.length === 1 OR options.project is set.
+
+                            const files = syncResponse.data.data.files;
+                            if (files && Array.isArray(files) && (projects.length === 1 || options.project)) {
+                                const fs = await import('fs/promises');
+                                const path = await import('path');
+
+                                for (const file of files) {
+                                    const filePath = path.join(process.cwd(), file.path);
+                                    await fs.mkdir(path.dirname(filePath), { recursive: true });
+                                    await fs.writeFile(filePath, file.content, 'utf-8');
+                                    // projectSpinner.text = `Wrote ${file.path}`; // Don't spam spinner
+                                }
+                                console.log(chalk.dim(`      💾 Wrote ${files.length} rule files to local .cursor/rules/`));
+                            }
+
+                            results.push({ projectId: project.id, projectName: project.name, status: 'success' });
+                        } else {
+                            projectSpinner.warn(chalk.yellow(`  ⚠️ ${project.name} → ${syncResponse.data.error || 'Unknown error'}`));
+                            results.push({ projectId: project.id, projectName: project.name, status: 'failed', error: syncResponse.data.error });
+                        }
+
+                    } catch (e: any) {
+                        projectSpinner.fail(chalk.red(`  ❌ ${project.name}: ${e.message}`));
+                        results.push({ projectId: project.id, projectName: project.name, status: 'failed', error: e.message });
+                    }
+                }
+
+                // Summary
+                console.log('');
+                console.log(chalk.bold('📊 Sync Summary:'));
+                const successful = results.filter(r => r.status === 'success').length;
+                const failed = results.filter(r => r.status === 'failed').length;
+                console.log(chalk.green(`  ✅ Successful: ${successful}`));
+                if (failed > 0) {
+                    console.log(chalk.red(`  ❌ Failed: ${failed}`));
+                }
+                console.log('');
+                console.log(chalk.cyan('🛡️ Frank Protocol v1.0 has been injected into the rules engine.'));
+                console.log(chalk.dim('   All new chats will now boot with mandatory governance checks.'));
+
+            } catch (e: any) {
+                spinner.fail(chalk.red('Sync failed: ' + e.message));
+            }
+        });
+
+    return syncRules;
+}