@rigstate/cli 0.6.0

package/src/commands/init.ts

@@ -0,0 +1,282 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import { loadManifest } from '../utils/manifest.js';
+import { getApiUrl, getApiKey, setProjectId } from '../utils/config.js';
+import axios from 'axios';
+
+export function createInitCommand() {
+    return new Command('init')
+        .description('Initialize or link a Rigstate project (interactive mode available)')
+        .argument('[project-id]', 'ID of the project to link (optional, prompts if not provided)')
+        .option('-f, --force', 'Overwrite existing .cursorrules file')
+        .option('--rules-only', 'Only regenerate .cursorrules without interactive setup')
+        .action(async (projectIdArg, options) => {
+            const spinner = ora('Initializing Rigstate project...').start();
+
+            let apiKey: string;
+            try {
+                apiKey = getApiKey();
+            } catch (e) {
+                spinner.fail(chalk.red('Not authenticated. Run "rigstate login" first.'));
+                return;
+            }
+
+            const apiUrl = getApiUrl();
+            let projectId = projectIdArg;
+
+            try {
+                // If --rules-only, just regenerate rules from existing manifest
+                if (options.rulesOnly) {
+                    const manifest = await loadManifest();
+                    if (!manifest) {
+                        spinner.fail('No .rigstate manifest found. Run "rigstate init" first.');
+                        return;
+                    }
+                    projectId = manifest.project_id;
+                    await generateRules(apiUrl, apiKey, projectId, options.force, spinner);
+                    return;
+                }
+
+                // Interactive mode if no project ID provided
+                if (!projectId) {
+                    spinner.stop();
+
+                    // Dynamic import for inquirer
+                    const inquirer = (await import('inquirer')).default;
+
+                    spinner.start('Fetching your projects...');
+
+                    // Fetch projects via API
+                    let projects: any[] = [];
+                    try {
+                        const projectsResponse = await axios.get(`${apiUrl}/api/v1/projects`, {
+                            headers: { Authorization: `Bearer ${apiKey}` }
+                        });
+                        if (projectsResponse.data.success) {
+                            projects = projectsResponse.data.data.projects || [];
+                        }
+                    } catch (e: any) {
+                        // API might not exist yet - fallback to manual entry
+                        spinner.info('Projects API not available. Using manual entry mode.');
+                    }
+
+                    spinner.stop();
+
+                    if (projects.length === 0) {
+                        // Fallback: Ask for project ID manually
+                        const { manualProjectId } = await inquirer.prompt([
+                            {
+                                type: 'input',
+                                name: 'manualProjectId',
+                                message: 'Enter Project ID (from Rigstate dashboard):',
+                                validate: (input: string) => input.trim() ? true : 'Project ID is required'
+                            }
+                        ]);
+                        projectId = manualProjectId;
+                    } else {
+                        // Build choices from fetched projects
+                        const choices: any[] = [
+                            { name: '➕ Create New Project', value: 'NEW' },
+                            new inquirer.Separator()
+                        ];
+
+                        projects.forEach((p: any) => {
+                            choices.push({
+                                name: `[${p.organization_name || 'Personal'}] ${p.name} (${p.status})`,
+                                value: p.id
+                            });
+                        });
+
+                        const { selectedId } = await inquirer.prompt([
+                            {
+                                type: 'list',
+                                name: 'selectedId',
+                                message: 'Select a project to link:',
+                                choices: choices,
+                                pageSize: 15
+                            }
+                        ]);
+
+                        if (selectedId === 'NEW') {
+                            // Create new project flow
+                            const { newName } = await inquirer.prompt([
+                                {
+                                    type: 'input',
+                                    name: 'newName',
+                                    message: 'Enter project name:',
+                                    validate: (input: string) => input.trim() ? true : 'Name is required'
+                                }
+                            ]);
+
+                            // Fetch organizations (with fallback)
+                            spinner.start('Fetching organizations...');
+                            let orgs: any[] = [];
+                            try {
+                                const orgsResponse = await axios.get(`${apiUrl}/api/v1/organizations`, {
+                                    headers: { Authorization: `Bearer ${apiKey}` }
+                                });
+                                orgs = orgsResponse.data.data?.organizations || [];
+                            } catch (e) {
+                                // API might not exist - skip org selection
+                            }
+                            spinner.stop();
+
+                            let selectedOrgId = orgs[0]?.id;
+
+                            if (orgs.length > 1) {
+                                const { orgId } = await inquirer.prompt([
+                                    {
+                                        type: 'list',
+                                        name: 'orgId',
+                                        message: 'Which organization does this belong to?',
+                                        choices: orgs.map((org: any) => ({
+                                            name: `${org.name} (${org.role || 'member'})`,
+                                            value: org.id
+                                        }))
+                                    }
+                                ]);
+                                selectedOrgId = orgId;
+                            }
+
+                            if (!selectedOrgId) {
+                                console.log(chalk.yellow('No organization available. Please create the project via the Rigstate dashboard.'));
+                                return;
+                            }
+
+                            // Create project via API
+                            spinner.start('Creating new project...');
+                            try {
+                                const createResponse = await axios.post(`${apiUrl}/api/v1/projects`, {
+                                    name: newName,
+                                    organization_id: selectedOrgId
+                                }, {
+                                    headers: { Authorization: `Bearer ${apiKey}` }
+                                });
+
+                                if (!createResponse.data.success) {
+                                    spinner.fail(chalk.red('Failed to create project: ' + createResponse.data.error));
+                                    return;
+                                }
+
+                                projectId = createResponse.data.data.project.id;
+                                spinner.succeed(chalk.green(`Created new project: ${newName}`));
+                            } catch (e: any) {
+                                spinner.fail(chalk.red('Project creation API not available. Please create via dashboard.'));
+                                return;
+                            }
+                        } else {
+                            projectId = selectedId;
+                        }
+                    }
+
+                    spinner.start(`Linking to project ID: ${projectId}...`);
+                }
+
+                // Core link logic
+                // Save project ID to config
+                setProjectId(projectId);
+
+                // Write local manifest
+                const manifestPath = path.join(process.cwd(), '.rigstate');
+                const manifestContent = {
+                    project_id: projectId,
+                    last_linked: new Date().toISOString(),
+                    api_url: apiUrl
+                };
+                await fs.writeFile(manifestPath, JSON.stringify(manifestContent, null, 2), 'utf-8');
+
+                // Initialize git if needed
+                try {
+                    await fs.access('.git');
+                } catch {
+                    spinner.text = 'Initializing git repository...';
+                    execSync('git init', { stdio: 'ignore' });
+                }
+
+                spinner.succeed(chalk.green(`✅ Linked to project: ${projectId}`));
+
+                // Generate rules
+                await generateRules(apiUrl, apiKey, projectId, options.force, spinner);
+
+                console.log('');
+                console.log(chalk.blue('Next steps:'));
+                console.log(chalk.dim('  rigstate sync     - Sync roadmap and context'));
+                console.log(chalk.dim('  rigstate watch    - Start development loop'));
+                console.log(chalk.dim('  rigstate focus    - Get current task'));
+
+            } catch (e: any) {
+                spinner.fail(chalk.red('Initialization failed: ' + e.message));
+            }
+        });
+}
+
+async function generateRules(apiUrl: string, apiKey: string, projectId: string, force: boolean, spinner: any) {
+    spinner.start('Generating AI rules (MDC + AGENTS.md)...');
+
+    try {
+        const response = await axios.post(`${apiUrl}/api/v1/rules/generate`, {
+            project_id: projectId
+        }, {
+            headers: { Authorization: `Bearer ${apiKey}` }
+        });
+
+        if (response.data.success || response.data.files) {
+            const files = response.data.files || [];
+
+            if (files.length === 0 && response.data.rules) {
+                // Fallback to legacy mono-file if no multiple files returned
+                const rulesPath = path.join(process.cwd(), '.cursorrules');
+                await fs.writeFile(rulesPath, response.data.rules, 'utf-8');
+                spinner.succeed(chalk.green('✔ Generated .cursorrules (legacy mode)'));
+                return;
+            }
+
+            for (const file of files) {
+                const targetPath = path.join(process.cwd(), file.path);
+                const targetDir = path.dirname(targetPath);
+
+                // Ensure directory exists
+                await fs.mkdir(targetDir, { recursive: true });
+
+                // Check if exists and force
+                try {
+                    await fs.access(targetPath);
+                    if (!force && !file.path.startsWith('.cursor/rules/')) {
+                        console.log(chalk.dim(`  ${file.path} already exists. Skipping.`));
+                        continue;
+                    }
+                } catch {
+                    // File doesn't exist, proceed
+                }
+
+                await fs.writeFile(targetPath, file.content, 'utf-8');
+            }
+
+            // Cleanup legacy .cursorrules if we have new files and aren't inhibited
+            if (files.length > 0) {
+                const legacyPath = path.join(process.cwd(), '.cursorrules');
+                try {
+                    const stats = await fs.stat(legacyPath);
+                    if (stats.isFile()) {
+                        await fs.rename(legacyPath, `${legacyPath}.bak`);
+                        console.log(chalk.dim('  Moved legacy .cursorrules to .cursorrules.bak'));
+                    }
+                } catch (e) {
+                    // Ignore if legacy file doesn't exist
+                }
+            }
+
+            spinner.succeed(chalk.green(`✔ Generated ${files.length} rule files (v${response.data.version || '3.0'})`));
+        } else {
+            spinner.info(chalk.dim('  Rules generation skipped (API response invalid)'));
+        }
+    } catch (e: any) {
+        spinner.info(chalk.dim(`  Rules generation failed: ${e.message}`));
+    }
+}
+
+

package/src/commands/link.ts

@@ -0,0 +1,45 @@
+import { Command } from 'commander';
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import os from 'os';
+
+export function createLinkCommand() {
+    return new Command('link')
+        .description('Link current directory to a Rigstate project')
+        .argument('<projectId>', 'Project ID to link')
+        .action(async (projectId) => {
+            // Check Global Override (Rigstate v2.7)
+            try {
+                const globalPath = path.join(os.homedir(), '.rigstate', 'config.json');
+                const globalData = await fs.readFile(globalPath, 'utf-8').catch(() => null);
+                if (globalData) {
+                    const config = JSON.parse(globalData);
+                    const cwd = process.cwd();
+                    if (config.overrides && config.overrides[cwd]) {
+                        const overrideId = config.overrides[cwd];
+                        if (overrideId !== projectId) {
+                            console.warn(chalk.yellow(`Global override detected. Enforcing project ID: ${overrideId}`));
+                            projectId = overrideId;
+                        }
+                    }
+                }
+            } catch (e) { }
+
+            const manifestPath = path.join(process.cwd(), '.rigstate');
+
+            const content = {
+                project_id: projectId,
+                api_url: process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000',
+                linked_at: new Date().toISOString()
+            };
+
+            try {
+                await fs.writeFile(manifestPath, JSON.stringify(content, null, 2), 'utf-8');
+                console.log(chalk.green(`✔ Linked to project ID: ${projectId}`));
+                console.log(chalk.dim(`Created local context manifest at .rigstate`));
+            } catch (error: any) {
+                console.error(chalk.red(`Failed to link project: ${error.message}`));
+            }
+        });
+}

package/src/commands/login.ts

@@ -0,0 +1,35 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { setApiKey } from '../utils/config.js';
+
+export function createLoginCommand(): Command {
+    return new Command('login')
+        .description('Authenticate with your Rigstate API key')
+        .argument('<api-key>', 'Your Rigstate API key (starts with sk_)')
+        .action(async (apiKey: string) => {
+            try {
+                // Basic validation
+                if (!apiKey || !apiKey.startsWith('sk_rigstate_')) {
+                    console.error(chalk.red('❌ Invalid API key format'));
+                    console.error(chalk.dim('API keys must start with "sk_rigstate_"'));
+                    process.exit(1);
+                }
+
+                // Store the API key
+                setApiKey(apiKey);
+
+                console.log(chalk.green('✅ Successfully logged in!'));
+                console.log(
+                    chalk.dim(
+                        `\nYour API key has been securely stored. You can now use "rigstate scan" to audit your code.`
+                    )
+                );
+            } catch (error) {
+                console.error(
+                    chalk.red('❌ Login failed:'),
+                    error instanceof Error ? error.message : 'Unknown error'
+                );
+                process.exit(1);
+            }
+        });
+}

package/src/commands/mcp.ts

@@ -0,0 +1,73 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+// ESM compatibility for __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function createMcpCommand() {
+    const mcp = new Command('mcp');
+
+    mcp
+        .description('Run the Rigstate MCP server for AI editors')
+        .action(async () => {
+            // Determine the path to the MCP server
+            const possiblePaths = [
+                // From packages/cli -> packages/mcp (sibling package)
+                path.resolve(__dirname, '../../mcp/dist/index.js'),
+                // If installed globally or via npm
+                path.resolve(__dirname, '../../../mcp/dist/index.js'),
+                // Development path from packages/cli/dist
+                path.resolve(__dirname, '../../../packages/mcp/dist/index.js'),
+            ];
+
+            let serverPath = '';
+            for (const p of possiblePaths) {
+                if (fs.existsSync(p)) {
+                    serverPath = p;
+                    break;
+                }
+            }
+
+            if (!serverPath) {
+                console.error(chalk.red('❌ Error: Rigstate MCP Server binary not found.'));
+                console.error(chalk.yellow('Please ensure that the mcp package is built:'));
+                console.error(chalk.white('   cd packages/mcp && npm run build'));
+                console.error('');
+                console.error(chalk.dim('Or run directly with:'));
+                console.error(chalk.white('   npx @rigstate/mcp'));
+                process.exit(1);
+            }
+
+            console.log(chalk.dim(`Starting MCP server from: ${serverPath}`));
+
+            // Map VIBE_API_KEY to RIGSTATE_API_KEY if needed (backwards compatibility)
+            if (process.env.VIBE_API_KEY && !process.env.RIGSTATE_API_KEY) {
+                process.env.RIGSTATE_API_KEY = process.env.VIBE_API_KEY;
+            }
+
+            // Spawn the MCP server as a child process
+            // MCP uses stdio for communication, so we inherit it
+            const worker = spawn('node', [serverPath], {
+                env: process.env,
+                stdio: ['inherit', 'inherit', 'inherit']
+            });
+
+            worker.on('error', (err) => {
+                console.error(chalk.red(`❌ Failed to start MCP server: ${err.message}`));
+                process.exit(1);
+            });
+
+            worker.on('exit', (code) => {
+                if (code !== 0 && code !== null) {
+                    process.exit(code);
+                }
+            });
+        });
+
+    return mcp;
+}

package/src/commands/nexus.ts

@@ -0,0 +1,81 @@
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { NexusDispatcher } from '../nexus/dispatcher.js';
+import { NexusContext } from '@rigstate/shared';
+import inquirer from 'inquirer';
+
+export function createNexusCommand() {
+    const command = new Command('nexus');
+
+    command
+        .description('Interact with The Multi-Agent Nexus (Phase 8)')
+        .argument('<intent>', 'The natural language instruction for the swarm')
+        .option('--dry-run', 'Enable Dry-Run mode (Kill-Switch Active)', true)
+        .option('--force', 'Disable Dry-Run mode (DANGEROUS)', false)
+        .action(async (intent: string, options) => {
+            console.log(chalk.bold.magenta('\n🦁 Welcome to The Nexus (Phase 8)\n'));
+
+            const dryRun = !options.force;
+
+            if (!dryRun) {
+                console.log(chalk.black.bgYellow(' WARNING ') + chalk.yellow(' Dry-Run disabled! Eitri is authorized to write code.'));
+                const { confirm } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you absolutely sure you want to bypass the Kill-Switch?',
+                    default: false
+                }]);
+                if (!confirm) {
+                    console.log('Aborting.');
+                    process.exit(0);
+                }
+            }
+
+            // Context setup
+            const context: NexusContext = {
+                projectId: process.env.RIGSTATE_PROJECT_ID || 'local',
+                rootPath: process.cwd(),
+                sessionUser: 'cli-user', // Should strictly be pulled from auth
+                dryRun
+            };
+
+            const dispatcher = new NexusDispatcher(context);
+
+            // Setup Listeners for Visualization
+            dispatcher.on('order:created', (o) => {
+                console.log(chalk.blue(`🆕 [${o.id.slice(0, 6)}] Order Created: `) + o.intent);
+            });
+
+            dispatcher.on('order:started', (o) => {
+                console.log(chalk.yellow(`⏳ [${o.id.slice(0, 6)}] Processing...`));
+            });
+
+            dispatcher.on('order:blocked', (o) => {
+                console.log(chalk.red(`🛑 [${o.id.slice(0, 6)}] BLOCKED by Kill-Switch`));
+                console.log(chalk.dim(`   Target: ${o.targetAgent} | Action: ${o.action}`));
+                console.log(chalk.dim('   Run with --force to execute automatically (NOT RECOMMENDED).'));
+            });
+
+            dispatcher.on('agent:SINDRE', (o) => console.log(chalk.cyan(`🤖 Sindre (Vault): I'm on it! (${o.action})`)));
+            dispatcher.on('agent:EITRI', (o) => console.log(chalk.green(`👷 Eitri (Smith): Ready to build! (${o.action})`)));
+
+            // Simulation: Frank Analysis Logic
+            // In a real scenario, this would call LLM/MCP to get the decomposition.
+            // Here we hardcode a mocked response to demonstrate the CLI flow.
+
+            console.log(chalk.dim('🧠 Frank is analyzing your intent...'));
+            await new Promise(r => setTimeout(r, 800)); // Simulate thinking
+
+            // MOCK: Dispatch logic
+            if (intent.toLowerCase().includes('db') || intent.toLowerCase().includes('database')) {
+                await dispatcher.dispatch('FRANK', 'SINDRE', intent, 'db.analyze', { raw: intent });
+            } else if (intent.toLowerCase().includes('create') || intent.toLowerCase().includes('code')) {
+                await dispatcher.dispatch('FRANK', 'EITRI', intent, 'fs.write', { path: 'src/demo.ts', content: '// demo' });
+            } else {
+                console.log(chalk.gray("Frank didn't understand. Try 'create file' or 'check database'."));
+            }
+        });
+
+    return command;
+}

package/src/commands/override.ts

@@ -0,0 +1,65 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { performOverride, getSessionState } from '../utils/governance.js';
+import { getApiKey, getProjectId, getApiUrl } from '../utils/config.js';
+import axios from 'axios';
+
+export function createOverrideCommand() {
+    const override = new Command('override');
+
+    override
+        .description('Emergency Override for Governance Soft Locks')
+        .argument('<violationId>', 'ID of the violation to override (or "all")')
+        .requiredOption('-r, --reason <reason>', 'Description of why this override is necessary')
+        .action(async (violationId, options) => {
+            const { reason } = options;
+
+            console.log(chalk.bold(`\n🔓 Initiating Governance Override Protocol...`));
+
+            const session = await getSessionState(process.cwd());
+
+            if (session.status !== 'SOFT_LOCK') {
+                console.log(chalk.yellow('   Info: Session is not currently locked.'));
+                return; // Not locked, but maybe we still want to log the "intent"?
+            }
+
+            console.log(chalk.dim(`   Active Violation: ${session.active_violation}`));
+            console.log(chalk.dim(`   Reason Provided:  "${reason}"`));
+
+            // Perform Local Unlock
+            const success = await performOverride(violationId, reason, process.cwd());
+
+            if (success) {
+                console.log(chalk.green(`   ✅ Session UNLOCKED.`));
+                console.log(chalk.dim(`   This event has been logged to the Mission Report.`));
+
+                // Optional: Notify Cloud about the Override (Audit Trail)
+                try {
+                    const projectId = getProjectId();
+                    if (projectId) {
+                        const apiUrl = getApiUrl();
+                        const apiKey = getApiKey();
+
+                        await axios.post(`${apiUrl}/api/v1/execution-logs`, {
+                            project_id: projectId,
+                            task_id: 'OVERRIDE-' + Date.now(),
+                            task_title: `Governance Override: ${violationId}`,
+                            status: 'COMPLETED',
+                            execution_summary: `Manual override executed. Reason: ${reason}`,
+                            agent_role: 'SUPERVISOR' // Override is a supervisor action
+                        }, {
+                            headers: { Authorization: `Bearer ${apiKey}` }
+                        });
+                        console.log(chalk.dim(`   ☁ Audit log synced to Cloud.`));
+                    }
+                } catch (e: any) {
+                    console.log(chalk.dim(`   (Cloud audit sync failed: ${e.message})`));
+                }
+
+            } else {
+                console.log(chalk.red(`   🛑 Override Failed. Check project configuration.`));
+            }
+        });
+
+    return override;
+}